<change id="XMLDataObject.subclass">

        <api name="loaders"/>

        <summary>New constructor of XMLDataObject</summary>

        <version major="7" minor="10"/>

        <date day="9" month="11" year="2009"/>

        <author login="jtulach"/>

        <compatibility binary="compatible" source="compatible" addition="yes"

            deletion="no" deprecation="no" modification="no" semantic="compatible"/>

        <description>

            <p>

                New constructor for subclasses of <code>XMLDataObject</code>.

            </p>

        </description>

        <class package="org.openide.loaders" name="XMLDataObject"/>

        <issue number="175750"/>

    </change>

        this(fo, loader, true);

    }

    /**

     * Constructs XMLDataObject without any registered cookies (for editor,

     * open, etc.). Useful for subclasses.

     *

     * @param fo the primary file object, never <code>null</code>

     * @param loader loader of this data object, never <code>null</code>

     * @param registerEditor call with false to skip registrations of various

     *   editor related cookies

     * @since 7.10

     */

    protected XMLDataObject (FileObject fo, MultiFileLoader loader, boolean registerEditor)

    throws DataObjectExistsException {

        if (registerEditor) {

            registerEditor();

        }

    }

    private void registerEditor() {

/*

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

 *

 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

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

 * by Sun 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]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * 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.

 */

package org.openide.loaders;

import java.util.Enumeration;

import org.openide.filesystems.*;

import java.io.*;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.security.Permission;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import java.util.logging.Level;

import junit.framework.Assert;

import org.netbeans.junit.Log;

import org.netbeans.junit.MockServices;

import org.netbeans.junit.RandomlyFails;

import org.openide.cookies.*;

import org.openide.loaders.MultiDataObject.Entry;

import org.openide.nodes.Node;

import org.openide.util.Enumerations;

import org.openide.util.RequestProcessor;

import org.openide.xml.XMLUtil;

import org.xml.sax.InputSource;

import org.xml.sax.SAXParseException;

/**

 *

 * @author  Jaroslav Tulach

 */

public class XMLDataObjectSubclassTest extends org.netbeans.junit.NbTestCase {

    private FileObject data;

    private CharSequence log;

    public XMLDataObjectSubclassTest (String name) {

        super (name);

    }

    @Override

    protected void setUp () throws Exception {

        clearWorkDir();

        MockServices.setServices(Pool.class);

        log = Log.enable("org.openide.loaders", Level.WARNING);

        super.setUp ();

        String fsstruct [] = new String [] {

        };

        FileSystem fs = TestUtilHid.createLocalFileSystem (getWorkDir(), fsstruct);

        data = FileUtil.createData (

            fs.getRoot (),

            "kuk/test/my.xml"

        );

        FileLock lock = data.lock ();

        OutputStream os = data.getOutputStream (lock);

        PrintStream p = new PrintStream (os);

        p.println ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");

        p.println ("<root>");

        p.println ("</root>");

        p.close ();

        lock.releaseLock ();

    }

    public void testCheckNoCookies() throws Exception {

        DataObject obj = DataObject.find(data);

        assertEquals("Correct obj type", MyXMLObject.class, obj.getClass());

        assertNull("No open cookie", obj.getLookup().lookup(OpenCookie.class));

        assertNull("No edit cookie", obj.getLookup().lookup(EditCookie.class));

        assertNull("No print cookie", obj.getLookup().lookup(PrintCookie.class));

        assertNull("No close cookie", obj.getLookup().lookup(CloseCookie.class));

    }

    public static final class Pool extends DataLoaderPool {

        @Override

        protected Enumeration<? extends DataLoader> loaders() {

            return Enumerations.singleton(DataLoader.getLoader(MyXMLLoader.class));

        }

    }

    public static final class MyXMLLoader extends UniFileLoader {

        public MyXMLLoader() {

            super(MyXMLObject.class.getName());

            getExtensions().addExtension("xml");

        }

        @Override

        protected MultiDataObject createMultiObject(FileObject primaryFile) throws DataObjectExistsException, IOException {

            return new MyXMLObject(primaryFile, this);

        }

    }

    public static final class MyXMLObject extends XMLDataObject {

        public MyXMLObject(FileObject fo, MultiFileLoader loader) throws DataObjectExistsException {

            super(fo, loader, false);

        }

    }

}

    public void testInconsistencyWhenDoubleCookie175750() {

        CookieSet cs = CookieSet.createGeneric(null);

        class Factory implements CookieSet.Factory {

            public <T extends Cookie> T createCookie(Class<T> klass) {

                if (klass == Cook.class || klass == Hook.class) {

                    return klass.cast(new Hook() { });

                }

                return null;

            }

        }

        final Factory f = new Factory();

        cs.add(new Class[] { Cook.class, Hook.class }, f);

        Cook one = cs.getCookie(Hook.class);

        Cook two = cs.getCookie(Cook.class);

        Cook three = cs.getLookup().lookup(Cook.class);

        Cook four = cs.getLookup().lookup(Hook.class);

        assertSame("One and two", one, two);

        assertSame("3 and two", three, two);

        assertSame("One and 4", one, four);

        cs.remove(new Class[] { Hook.class, Cook.class }, f);

        assertNull("No cookie now ", cs.getCookie(Cook.class));

        assertNull("No lkp now ", cs.getLookup().lookup(Cook.class));

        assertNull("No h cookie now ", cs.getCookie(Hook.class));

        assertNull("No h lkp now ", cs.getLookup().lookup(Hook.class));

    }

    static interface Hook extends Cook {

    }

import org.openide.cookies.OpenCookie;

import org.openide.windows.WindowManager;

    static {

        System.setProperty ("org.openide.util.Lookup", "org.openide.text.DataEditorSupportTest$Lkp");

        System.setProperty("org.openide.windows.DummyWindowManager.VISIBLE", "false");

    }

        OpenCookie lkp2 = dataObject.getLookup().lookup(OpenCookie.class);

        lkp.edit();

        lkp2.open();

        Set<?> all = null;

        for (int i = 0; i < 10; i++) {

            Thread.sleep(1000);

            all = WindowManager.getDefault().getRegistry().getOpened();

            if (all.size() > 0) {

                break;

            }

        }

        assertEquals("There is just one TC: " + all, 1, all.size());

        assertEquals("Cookies are the same", lkp, lkp2);