MakeResolver=Makefiles

import org.openide.filesystems.MIMEResolver;

@MIMEResolver.Registration(

        displayName="#MakeResolver",

        position=139,

        resource="../../script/resources/mime-resolver-make.xml",

        showInFileChooser="#MakeResolver")

FILECHOOSER_C_SOURCES_FILEFILTER=C Source Files

FILECHOOSER_CC_SOURCES_FILEFILTER=C++ Source Files

FILECHOOSER_HEADER_SOURCES_FILEFILTER=Header Files

FILECHOOSER_FORTRAN_SOURCES_FILEFILTER=Fortran Source Files

import org.openide.filesystems.MIMEResolver;

import org.openide.filesystems.MIMEResolver;

import org.openide.filesystems.MIMEResolver;

QtNameExtResolver=Qt Files

import org.openide.filesystems.MIMEResolver;

@MIMEResolver.Registration(

    displayName = "#QtNameExtResolver", // NOI18N

    position = 215,

    resource = "../resources/mime-resolver-ext-based-qt.xml", // NOI18N

    showInFileChooser={"#QtNameExtResolver"}

)

ResourceFiles=Resource Files

ResourceFiles=Resource Files

        showInFileChooser={"#ResourceFiles"},

        showInFileChooser={"#ResourceFiles"},

        showInFileChooser={"#ResourceFiles"},

        showInFileChooser={"#ResourceFiles"},

        <change id="FileChooserBuilder-addDefaultFileFilters">

            <api name="filesystems"/>

            <summary>New method FileChooserBuilder.addDefaultFileFilters and accompanying annotations.</summary>

            <version major="8" minor="1"/>

            <date year="2012" month="8" day="29"/>

            <author login="jhavlin"/>

            <compatibility addition="yes" deprecation="no"/>

            <description>

                <p>

                    Added <a href="@TOP@org/openide/filesystems/FileChooserBuilder.html#addDefaultFileFilters()">

                    new method</a> to <code>FileChooserBuilder</code> that adds all default

                    <code>FileFilter</code>s to created file chooser.

                </p>

                <p>

                    Default filters are registered using new parameters in annotations

                    <a href="@TOP@org/openide/filesystems/MIMEResolver.Registration.html#showInFileChooser()">MimeResolver.Registration</a>

                    and <a href="@TOP@org/openide/filesystems/MIMEResolver.ExtensionRegistration.html#showInFileChooser()">MimeResolver.ExtensionRegistration</a>.

                </p>

            </description>

            <class package="org.openide.filesystems" name="FileChooserBuilder"/>

            <class package="org.openide.filesystems" name="MIMEResolver"/>

            <issue number="209998"/>

        </change>

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.openide.filesystems;

import java.io.File;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.swing.filechooser.FileFilter;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

/**

 * Support methods for creation of registered {@link FileFilter file filters}.

 */

public final class FileFilterSupport {

    /**

     * The logger.

     */

    private static final Logger LOG = Logger.getLogger(

            FileFilterSupport.class.getName());

    /**

     * Hide the default constructor.

     */

    private FileFilterSupport() {

    }

    /**

     * Construct description for {@link FileFilter} that accepts files with

     * specified extension.

     *

     * @param displayName Human readable display name (e.g. "HTML files")

     * @param elements List of accepted filter elements.

     *

     * @return Display name (description) for the filter.

     */

    private static String constructFilterDisplayName(String displayName,

            List<FilterElement> elements) {

        StringBuilder sb = new StringBuilder(displayName);

        boolean first = true;

        sb.append(" [");                                                //NOI18N

        for (FilterElement el : elements) {

            if (first) {

                first = false;

            } else {

                sb.append(", ");                                        //NOI18N

            }

            sb.append(el.getName());

        }

        sb.append("]");                                                 //NOI18N

        return sb.toString();

    }

    /**

     * Check whether passed file is accepted by filter for specified list of

     * extensions.

     *

     * @param file File to be accepted or rejected.

     * @param elements List of accepted filter elements.

     *

     * @return True if the file is accepted, false if it is rejected.

     *

     * @see FileFilterSupport

     */

    private static boolean accept(File file, List<FilterElement> elements) {

        if (file != null) {

            if (file.isDirectory()) {

                return true;

            }

            for (FilterElement elm : elements) {

                if (elm.accept(file)) {

                    return true;

                }

            }

        }

        return false;

    }

    public static List<FileFilter> findRegisteredFileFilters() {

        List<FileFilter> filters = new LinkedList<FileFilter>();

        FileObject root = FileUtil.getConfigFile(

                "Services/MIMEResolver");                               //NOI18N

        Map<String, Set<FileObject>> filterNameToResolversMap =

                new HashMap<String, Set<FileObject>>();

        for (FileObject child : root.getChildren()) {

            if (child.isFolder()) {

                continue;

            }

            int i = 0;

            String f;

            while ((f = (String) child.getAttribute("fileChooser." + i))//NOI18N

                    != null) {

                Set<FileObject> set = filterNameToResolversMap.get(f);

                if (set == null) {

                    set = new HashSet<FileObject>();

                    filterNameToResolversMap.put(f, set);

                }

                set.add(child);

                i++;

            }

        }

        for (Map.Entry<String, Set<FileObject>> e :

                filterNameToResolversMap.entrySet()) {

            filters.add(createFilter(e.getKey(), e.getValue()));

        }

        return sortFiltersByDescription(filters);

    }

    private static FileFilter createFilter(final String name,

            final Set<FileObject> resolvers) {

        ArrayList<FilterElement> elems = new ArrayList<FilterElement>(3);

        String lastAtt;

        for (FileObject fo : resolvers) {

            int i = 0;

            while ((lastAtt = (String) fo.getAttribute(

                    "ext." + i)) != null) { //NOI18N

                addExtensionToList(elems, lastAtt);

                i++;

            }

            int n = 0;

            while ((lastAtt = (String) fo.getAttribute("fileName." //NOI18N

                    + (n++))) != null) {

                addNameToList(elems, lastAtt);

            }

            String type;

            if ((type = (String) fo.getAttribute("mimeType")) != null) {//NOI18N

                addMimeTypeExts(elems, type);

            }

            int t = 0;

            while ((type = (String) fo.getAttribute(

                    "mimeType." + (t++))) != null) {     //NOI18N

                addMimeTypeExts(elems, type);

            }

        }

        sortFilterElements(elems);

        return new FileFilterImpl(name, elems);

    }

    /**

     * Add all extensions assigned to a MIME Type to the extension list.

     */

    private static void addMimeTypeExts(List<FilterElement> exts, String type) {

        addAllExtensionsToList(exts, FileUtil.getMIMETypeExtensions(type));

    }

    /**

     * Add new items to list of extensions, prevent duplicates.

     *

     * @param list List of extensions to alter.

     * @param toAdd List of extensions (without starting dot) to add.

     */

    private static void addAllExtensionsToList(List<FilterElement> list,

            List<String> toAdd) {

        for (String s : toAdd) {

            addExtensionToList(list, s);

        }

    }

    /**

     * Add new item to list of extensions, prevent duplacates.

     *

     * @param list List of extensions to alter.

     * @param s Extensions without starting dot.

     */

    private static void addExtensionToList(List<FilterElement> list,

            String ext) {

        addFilterElementToList(list, FilterElement.createForExtension(ext));

    }

    private static void addNameToList(List<FilterElement> list, String name) {

        Pattern p = Pattern.compile(

                "\\[([^,]+), (true|false), (true|false)\\](\\S*)");     //NOI18N

        Matcher m = p.matcher(name);

        if (m.find()) {

            String fileName = m.group(1);

            boolean substring = m.group(2).equals("true");              //NOI18N

            boolean ignoreCase = m.group(3).equals("true");             //NOI18N

            String extension = m.group(4);

            addFilterElementToList(list, FilterElement.createForFileName(

                    fileName, extension, substring, ignoreCase));

        } else {

            LOG.log(Level.INFO, "Incorrect name pattern {0}", name);    //NOI18N

        }

    }

    private static void addFilterElementToList(List<FilterElement> list,

            FilterElement newItem) {

        for (int i = 0; i < list.size(); i++) {

            FilterElement el = list.get(i);

            FilterElement.ComparisonResult result = newItem.compare(el);

            switch (result) {

                case DIFFERENT:

                    continue;

                case THE_SAME:

                case WORSE:

                    return;

                case BETTER:

                    list.set(i, newItem);

                    return;

            }

        }

        list.add(newItem);

    }

    private static List<FileFilter> sortFiltersByDescription(

            List<FileFilter> list) {

        Collections.sort(list, new Comparator<FileFilter>() {

            @Override

            public int compare(FileFilter o1, FileFilter o2) {

                return o1.getDescription().compareTo(o2.getDescription());

            }

        });

        return list;

    }

    private static List<FilterElement> sortFilterElements(

            List<FilterElement> elements) {

        Collections.sort(elements, new Comparator<FilterElement>() {

            @Override

            public int compare(FilterElement o1, FilterElement o2) {

                return o1.getName().compareTo(o2.getName());

            }

        });

        return elements;

    }

    private static class FileFilterImpl extends FileFilter {

        private final String name;

        List<FilterElement> filterElements;

        public FileFilterImpl(String name, List<FilterElement> elements) {

            this.name = name;

            this.filterElements = elements;

        }

        @Override

        public boolean accept(File pathname) {

            return FileFilterSupport.accept(pathname, filterElements);

        }

        @Override

        public String getDescription() {

            return FileFilterSupport.constructFilterDisplayName(

                    name, filterElements);

        }

    }

    /**

     * Element of File Filter. One accepted extension or file name pattern.

     */

    private static abstract class FilterElement {

        public abstract String getName();

        public abstract boolean accept(File f);

        /**

         * Compare two filter elements. Correct implementation of this method

         * prevents adding duplicite elements to the filter.

         */

        public abstract ComparisonResult compare(FilterElement e);

        public static FilterElement createForExtension(String ext) {

            return new ExtensionBasedFilterElement(ext);

        }

        public static FilterElement createForFileName(String name,

                String extension, boolean substring, boolean ignoreCase) {

            return new NameBasedFilterElement(name, extension,

                    substring, ignoreCase);

        }

        public static enum ComparisonResult {

            THE_SAME, BETTER, WORSE, DIFFERENT

        }

        private static class ExtensionBasedFilterElement extends FilterElement {

            private final String extension;

            public ExtensionBasedFilterElement(String extension) {

                if (extension != null) {

                    this.extension = extension;

                } else {

                    throw new NullPointerException();

                }

            }

            @Override

            public String getName() {

                return "." + extension;                                 //NOI18N

            }

            @Override

            public boolean accept(File f) {

                return f.getName().toLowerCase().endsWith(

                        "." + extension.toLowerCase());                 //NOI18N

            }

            @Override

            public ComparisonResult compare(FilterElement e) {

                if (!(e instanceof ExtensionBasedFilterElement)) {

                    return ComparisonResult.DIFFERENT;

                }

                ExtensionBasedFilterElement x = (ExtensionBasedFilterElement) e;

                if (x == null) {

                    throw new NullPointerException();

                }

                if (this.extension.equals(x.extension)) {

                    return ComparisonResult.THE_SAME;

                } else if (this.extension.equalsIgnoreCase(x.extension)

                        && this.extension.length() > 1) {

                    if (Character.isUpperCase(x.extension.charAt(0))) {

                        return ComparisonResult.BETTER; //this better, x worse

                    } else {

                        return ComparisonResult.WORSE; // this worse, x better

                    }

                } else {

                    return ComparisonResult.DIFFERENT;

                }

            }

        }

        private static class NameBasedFilterElement extends FilterElement {

            String name;

            String ext;

            boolean substring;

            boolean ignoreCase;

            Pattern p;

            public NameBasedFilterElement(String name, String ext,

                    boolean substring, boolean ignoreCase) {

                this.name = name;

                this.ext = ext;

                this.substring = substring;

                this.ignoreCase = ignoreCase;

                StringBuilder sb = new StringBuilder();

                if (ignoreCase) {

                    sb.append("(?i)");                                  //NOI18N

                }

                if (substring) {

                    sb.append(".*");                                    //NOI18N

                }

                sb.append(name);                                        //NOI18N

                if (substring) {

                    sb.append(".*");                                    //NOI18N

                }

                if (!ext.isEmpty()) {

                    sb.append("\\.");                                   //NOI18N

                    sb.append(ext);

                }

                p = Pattern.compile(sb.toString());

            }

            @Override

            public String getName() {

                return name + (ext.isEmpty() ? "" : "." + ext);         //NOI18N

            }

            @Override

            public boolean accept(File f) {

                return p.matcher(f.getName()).matches();

            }

            @Override

            public ComparisonResult compare(FilterElement e) {

                if (e == null) {

                    throw new NullPointerException();

                } else if (!(e instanceof NameBasedFilterElement)) {

                    return ComparisonResult.DIFFERENT;

                }

                NameBasedFilterElement x = (NameBasedFilterElement) e;

                if (this.name.equals(x.name) && this.ext.equals(x.ext)) {

                    if (this.substring == x.substring

                            && this.ignoreCase == x.ignoreCase) {

                        return ComparisonResult.THE_SAME;

                    } else {

                        return compareFlags(x);

                    }

                } else if (this.ext.equalsIgnoreCase(x.ext)

                        && this.name.equalsIgnoreCase(x.name)

                        && (this.ignoreCase || x.ignoreCase)) {

                    if (this.substring == x.substring

                            && this.ignoreCase == x.ignoreCase) {

                        if (Character.isLowerCase(this.name.charAt(0))) {

                            return ComparisonResult.BETTER;

                        } else {

                            return ComparisonResult.WORSE;

                        }

                    } else {

                        return compareFlags(x);

                    }

                } else {

                    return ComparisonResult.DIFFERENT;

                }

            }

            private ComparisonResult compareFlags(NameBasedFilterElement x) {

                if (this.substring == x.substring

                        && this.ignoreCase) {

                    return ComparisonResult.BETTER;

                } else if (this.ignoreCase == x.ignoreCase

                        && this.substring) {

                    return ComparisonResult.BETTER;

                } else if (this.substring != x.substring

                        && this.ignoreCase != x.ignoreCase) {

                    return ComparisonResult.DIFFERENT;

                } else {

                    return ComparisonResult.WORSE;

                }

            }

        }

    }

}

    List<Type.FileName> getNames() {

        return fileCheck.names;

    }

        @Override

        public List<String> getExtensions() {

            if (smell == null) {

                return Collections.emptyList();

            } else {

                List<String> extensions = new LinkedList<String>();

                for (FileElement fe : smell) {

                    if (fe != null && fe.getExtensions() != null

                            && (fe.getNames() == null

                            || fe.getNames().isEmpty())) {

                        for (String ext : fe.getExtensions()) {

                            if (ext != null && !ext.isEmpty()) {

                                extensions.add(ext);

                            }

                        }

                    }

                }

                return extensions;

            }

        }

        @Override

        public List<String> getFileNames() {

            if (smell == null) {

                return Collections.emptyList();

            } else {

                List<String> fileNames = new LinkedList<String>();

                for (FileElement fe : smell) {

                    if (fe != null && fe.getNames() != null) {

                        for (Type.FileName name : fe.getNames()) {

                            String[] exts = fe.getExtensions();

                            if (exts == null || exts.length == 0) {

                                continue;

                            }

                            for (String ext : exts) {

                                fileNames.add(name.toString() + ext);

                            }

                        }

                    }

                }

                return fileNames;

            }

        }

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

        int ccnt = 0;

        for (String chooser : r.showInFileChooser()) {

            f.bundlevalue("fileChooser." + (ccnt++), chooser);

        }

        int ccnt = 0;

        for (String chooser : r.showInFileChooser()) {

            f.bundlevalue("fileChooser." + (ccnt++), chooser);

        }

    private Set<String> unq(String[] array) {

        return unq(Arrays.asList(array));

    }

    private Set<String> unq(Collection collection) {

        Set<String> s = new HashSet();

        s.addAll(collection);

        return s;

    }

    private void setFileChooserRelatedAttributes(Registration r,

            MIMEResolver resolver, File f) {

        if (r.showInFileChooser().length > 0) {

            String[] types = MIMEResolverImpl.getMIMETypes(resolver);

            List<String> exts = ((FilterInfo) resolver).getExtensions();

            int cnt = 0;

            for (String ext : unq(exts)) {

                f.stringvalue("ext." + (cnt++), ext);              // NOI18N

            }

            int tcnt = 0;

            for (String type : unq(types)) {

                f.stringvalue("mimeType." + (tcnt++), type);       // NOI18N

            }

            int ncnt = 0;

            for (String name : ((FilterInfo) resolver).getFileNames()) {

                f.stringvalue("fileName." + (ncnt++), name);        //NOI18N

            }

        }

    }

    /**

     * Interface of objects that provide information for construction of

     * FileFilters.

     */

    interface FilterInfo {

        List<String> getExtensions();

        List<String> getFileNames();

    }

import org.netbeans.modules.openide.filesystems.FileFilterSupport;

     * Add all default file filters to the file chooser.

     *

     * @see MIMEResolver.Registration#showInFileChooser()

     * @see MIMEResolver.ExtensionRegistration#showInFileChooser()

     * @return this

     * @since 8.1

     */

    public FileChooserBuilder addDefaultFileFilters() {

        filters.addAll(FileFilterSupport.findRegisteredFileFilters());

        return this;

    }

    /**

        /**

         * Show file filters for this MIME type. Set localized names of file

         * filters that should contain files resolved by this resolver.

         *

         * @see FileChooserBuilder#addDefaultFileFilters()

         * @since 8.1

         */

        public String[] showInFileChooser() default {};

        /**

         * Show file filters for registered MIME types. Set localized names of

         * file filters that should accept files resolved by this resolver. Only

         * types resolved by file name or extension (not by file content) are

         * supported.

         *

         * @see FileChooserBuilder#addDefaultFileFilters()

         * @since 8.1

         */

        public String[] showInFileChooser() default {};

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.openide.filesystems;

import java.io.File;

import java.util.List;

import javax.swing.filechooser.FileFilter;

import org.netbeans.junit.NbTestCase;

import org.openide.filesystems.MIMEResolver;

import org.openide.util.NbBundle;

/**

 * Test registered FileFilters.

 *

 * @author jhavlin

 */

@NbBundle.Messages({

    "RESOLVER=Resolver",

    "FILECHOOSER=BNM Files"

})

@MIMEResolver.Registration(

    displayName = "#RESOLVER",

resource = "mime-resolver-filechooser.xml",

showInFileChooser = "#FILECHOOSER")

public class FileFilterSupportTest extends NbTestCase {

    public FileFilterSupportTest(String name) {

        super(name);

    }

    /**

     * This test, although it is quite short, tests a lot of ascpects of default

     * file filters. The resolver definition XML file contains several

     * duplicities, which are detected and ignored. If this detection fails,

     * filter description and {@code accept} method is changed, and it is cought

     * by this test.

     */

    public void testRegisteredFilters() {

        List<FileFilter> list = FileFilterSupport.findRegisteredFileFilters();

        assertNotNull(list);

        assertFalse(list.isEmpty());

        boolean found = false;

        for (FileFilter filter : list) {

            if (filter.getDescription().startsWith("BNM Files")) {

                found = true;

                checkBnmFilesFilter(filter);

            }

        }

        assertTrue("Registered File Filter was not found.", found);

    }

    private void checkBnmFilesFilter(FileFilter f) {

        assertEquals("BNM Files [.bnm, bnmHelp, bnmProject, bnminfo, bnmsettings]",

                f.getDescription());

        assertTrue(f.accept(new File("first.bnm")));

        assertTrue(f.accept(new File("second.BNM")));

        assertTrue(f.accept(new File("third.bNm")));

        assertTrue(f.accept(new File("bnmProject")));

        assertTrue(f.accept(new File("PREFIXbnmProjectAndSuFfIx")));

        assertFalse(f.accept(new File("bnmproject")));

        assertTrue(f.accept(new File("bnmSettings")));

        assertTrue(f.accept(new File("BNMSETTINGS")));

        assertFalse(f.accept(new File("bnmSettingsX")));

        assertTrue(f.accept(new File("bnmInfo")));

        assertTrue(f.accept(new File("AbnmInfoB")));

        assertTrue(f.accept(new File("aBNMINFOb")));

        assertTrue(f.accept(new File("bnmHelp")));

        assertFalse(f.accept(new File("bnmhelp")));

        assertFalse(f.accept(new File("bnmHelpX")));

        assertFalse(f.accept(new File("foo.txt")));

    }

}

    public void testExtensionFileFilterRegistration() {

        final String PATH = "Services/MIMEResolver/"

                + "org-netbeans-modules-openide-filesystems-declmime-MIMEResolverProcessorTest-Registration.xml";

        FileObject fo = FileUtil.getConfigFile(PATH);

        assertNotNull(fo);

        assertEquals("xml", fo.getAttribute("ext.0"));

        assertEquals("[importantName, true, false]bnm", fo.getAttribute("fileName.0"));

        assertEquals("text/x-ant+xml", fo.getAttribute("mimeType.0"));

        assertEquals("text/x-bnm", fo.getAttribute("mimeType.1"));

        assertEquals("XML and BNM Files", fo.getAttribute("fileChooser.0"));

    }

    public void testResourceFileFilterRegistration() {

        final String PATH = "Services/MIMEResolver/"

                + "org-netbeans-modules-openide-filesystems-declmime-MIMEResolverProcessorTest-Extension.xml";

        FileObject fo = FileUtil.getConfigFile(PATH);

        assertNotNull(fo);

        assertEquals("abc", fo.getAttribute("ext.0"));

        assertEquals("xyz", fo.getAttribute("ext.1"));

        assertEquals("text/x-yz", fo.getAttribute("mimeType"));

        assertEquals("ABC and XYZ Files", fo.getAttribute("fileChooser.0"));

        assertEquals("Test Files", fo.getAttribute("fileChooser.1"));

    }

    <file>

        <ext name="bnm"/>

        <name name="importantName" substring="true" ignorecase="false" />

        <resolver mime="text/x-bnm"/>

    </file>