Attachment #63531 for bug #138076

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 138076
Collapse All | Expand All

Lines 81-86 import org.openide.util.Enumerations; Link Here

(-)a/core.startup/src/org/netbeans/core/startup/layers/BinaryFS.java (+4 lines)
81	import org.openide.util.Enumerations;	81	import org.openide.util.Enumerations;
82	import org.openide.util.Exceptions;	82	import org.openide.util.Exceptions;
83	import org.openide.util.Lookup;	83	import org.openide.util.Lookup;
		84	import org.openide.util.NbBundle;
84	import org.openide.util.SharedClassObject;	85	import org.openide.util.SharedClassObject;
85	import org.openide.util.Union2;	86	import org.openide.util.Union2;
86	import org.openide.util.actions.SystemAction;	87	import org.openide.util.actions.SystemAction;
Lines 494-499 public class BinaryFS extends FileSystem Link Here
494		495
495	case 12: // serialvalue	496	case 12: // serialvalue
496	return decodeValue(value);	497	return decodeValue(value);
		498	case 13: // bundle value
		499	String[] arr = value.split("#");
		500	return NbBundle.getBundle(arr[0]).getObject(arr[1]);
497	default:	501	default:
498	throw new IllegalStateException("Bad index: " + index); // NOI18N	502	throw new IllegalStateException("Bad index: " + index); // NOI18N
499	}	503	}

Lines 80-85 abstract class ParsingLayerCacheManager Link Here

(-)a/core.startup/src/org/netbeans/core/startup/layers/ParsingLayerCacheManager.java (-1 / +2 lines)
80		80
81	private final static String[] ATTR_TYPES = {	81	private final static String[] ATTR_TYPES = {
82	"boolvalue",	82	"boolvalue",
		83	"bundlevalue",
83	"bytevalue",	84	"bytevalue",
84	"charvalue",	85	"charvalue",
85	"doublevalue",	86	"doublevalue",
Lines 91-97 abstract class ParsingLayerCacheManager Link Here
91	"serialvalue",	92	"serialvalue",
92	"shortvalue",	93	"shortvalue",
93	"stringvalue",	94	"stringvalue",
94	"urlvalue"	95	"urlvalue",
95	};	96	};
96		97
97	private final static String DTD_1_0 = "-//NetBeans//DTD Filesystem 1.0//EN";	98	private final static String DTD_1_0 = "-//NetBeans//DTD Filesystem 1.0//EN";





package org.netbeans.core.startup.layers;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.ByteBuffer;
import java.util.Arrays;
import junit.framework.Test;
import org.netbeans.junit.NbTestSuite;

import org.openide.filesystems.FileSystemTestHid;
import org.openide.filesystems.TestUtilHid;
import org.openide.filesystems.XMLFileSystem;
import org.openide.filesystems.XMLFileSystemTestHid;

/**
 *
 * @author Radek Matous
 */
public class BinaryFSTest extends FileSystemFactoryHid
implements XMLFileSystemTestHid.Factory {
    public BinaryFSTest(Test test) {
        super(test);
    }

        suite.addTestSuite(FileSystemTestHid.class);
        suite.addTestSuite(FileObjectTestHid.class);
        suite.addTestSuite(AttributesTestHidden.class);
        suite.addTestSuite(XMLFileSystemTestHid.class);
         
        return new BinaryFSTest(suite);
    }

        String workDirProperty = System.getProperty("workdir");//NOI18N
        workDirProperty = (workDirProperty != null) ? workDirProperty : System.getProperty("java.io.tmpdir");//NOI18N                 
        return new File(workDirProperty);
    }

    public FileSystem createLayerSystem(String testName, URL[] layers) throws IOException {
        LayerCacheManager bm = LayerCacheManager.manager(true);
        return BinaryCacheManagerTest.store(bm, Arrays.asList(layers));
    }

    public boolean setXmlUrl(FileSystem fs, URL[] layers) throws IOException {
        return false;
    }
}

Lines 388-394 final class XMLMapAttr implements Map { Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/XMLMapAttr.java (-1 / +4 lines)
388	// static final long serialVersionUID = -62733358015297232L;	388	// static final long serialVersionUID = -62733358015297232L;
389	private static final String[] ALLOWED_ATTR_KEYS = {	389	private static final String[] ALLOWED_ATTR_KEYS = {
390	"bytevalue", "shortvalue", "intvalue", "longvalue", "floatvalue", "doublevalue", "boolvalue", "charvalue",	390	"bytevalue", "shortvalue", "intvalue", "longvalue", "floatvalue", "doublevalue", "boolvalue", "charvalue",
391	"stringvalue", "methodvalue", "serialvalue", "urlvalue", "newvalue"	391	"stringvalue", "methodvalue", "serialvalue", "urlvalue", "newvalue", "bundlevalue"
392	}; // NOI18N	392	}; // NOI18N
393	private String value;	393	private String value;
394	private int keyIndex;	394	private int keyIndex;
Lines 865-870 final class XMLMapAttr implements Map { Link Here
865	} else {	865	} else {
866	return cls.newInstance();	866	return cls.newInstance();
867	}	867	}
		868	case 13:
		869	String[] arr = value.split("#");
		870	return NbBundle.getBundle(arr[0]).getObject(arr[1]);
868	}	871	}
869	} catch (Exception exc) {	872	} catch (Exception exc) {
870	ExternalUtil.annotate(exc, "value = " + value); //NOI18N	873	ExternalUtil.annotate(exc, "value = " + value); //NOI18N





package org.openide.filesystems;

import junit.framework.*;
//import org.openide.filesystems.hidden.*;

import java.util.*;
import java.io.*;
import java.net.URL;

/**
 *

 *
 */
public class AttributesTestHidden extends TestBaseHid {

    static final String TEST_ERR = "Not the tested code, but this test contains errors";
    static final String COMMON_ATTR_STRING = "testAttribute";


        assertTrue ("There was not found expected key: " + COMMON_ATTR_STRING +" in .nbattrs",content.indexOf("name=\""+COMMON_ATTR_STRING) != -1 );//        
    }
    
    
    public void testAttribute08 () throws Exception {
      URL fsURLDef = this.getClass().getResource ("data/Attributes.xml");
      assertTrue ("Cannot create XML FS for testing purposes", fsURLDef != null);  
      FileSystem fs = new XMLFileSystem (fsURLDef);
      FileObject fo = fs.findResource("testMethodValue");
      assertTrue ("Cannot acces  FileObject named testMethodValue", fo != null);  

      String testName = "test1";
      Object obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertTrue ("methodValue doesn't keep order ", 
      obj.equals(getObjectViaMethodValue1 (fo, testName)));                
      
      testName = "test2";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertTrue ("methodValue doesn't keep order ", 
      obj.equals(getObjectViaMethodValue2 (testName, fo)));                

      testName = "test3";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertTrue ("methodValue doesn't keep order ", 
      obj.equals(getObjectViaMethodValue3 (fo)));                

      testName = "test4";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertTrue ("methodValue doesn't keep order ", 
      obj.equals(getObjectViaMethodValue4 (testName)));                

      testName = "test5";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertTrue ("methodValue doesn't keep order ", 
      obj.equals(getObjectViaMethodValue5 ()));                     

      testName = "test6";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertEquals("even works for java.util.Map", "Ahoj1", obj);

      testName = "test7";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);          
      assertEquals("works for map and string", "Ahoj1test7", obj);  
    }

    public void testAttribute09 () throws IOException {
        assertTrue (TEST_ERR,testedFS != null);
        if (testedFS.isReadOnly ()) return;                

        }                        
    }
    
    private static String getObjectViaMethodValue1 (FileObject fo, String testName) {
        return fo.getPath()+testName;
    }

    private static String getObjectViaMethodValue1 (String testName, FileObject fo) {
        return testName+fo.getPath();
    }

    private static String getObjectViaMethodValue1 (FileObject fo) {
        return fo.getPath();        
    }
    
    private static String getObjectViaMethodValue1 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue1 () {
        return "";        
    }
///
    private static String getObjectViaMethodValue2 (String testName, FileObject fo) {
        return testName+fo.getPath();
    }

    private static String getObjectViaMethodValue2 (FileObject fo) {
        return fo.getPath();        
    }
    
    private static String getObjectViaMethodValue2 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue2 () {
        return "";        
    }
///
    private static String getObjectViaMethodValue3 (FileObject fo) {
        return fo.getPath();        
    }

    private static String getObjectViaMethodValue3 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue3 () {
        return "";        
    }
///
    private static String getObjectViaMethodValue4 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue4 () {
        return "";        
    }
///
    private static String getObjectViaMethodValue5 () {
        return "";        
    }
            
    private static Object getObjectViaMethodValue6 (Map attrs) {
        try {
            attrs.keySet().iterator().remove();
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        try {
            attrs.put("value1", "nothing");
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        try {
            attrs.remove("value1");
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        
        
        return attrs.get("value1");
    }
    private static Object getObjectViaMethodValue7 (Map<String,Object> attrs, String attrName) {
        assertEquals(8, attrs.keySet().size());
        try {
            attrs.entrySet().remove(null);
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        
        
        return attrs.get("value1") + attrName;
    }
            
    private String basicAttributeTest (String attrName, String attrValue) throws IOException {
        FileObject foTested = testedFS.getRoot ();        




import org.netbeans.junit.*;

import java.io.*;
import java.net.URL;
import java.util.*;

import org.openide.filesystems.*;


/**

     * @return  array of FileSystems that should be tested in test named: "testName"*/    
    final static FileSystem[] createFileSystem (String testName,String[] resources, Test test) throws IOException {
         return getInstance (test,true).createFileSystem(testName, resources);
    }

    /**
     * Intended to allow prepare tested environment for each individual test.
     * @param testName name of test
     * @return  array of FileSystems that should be tested in test named: "testName"*/
    final static FileSystem createXMLSystem (String testName, Test test, URL... layers) throws IOException {
        FileSystemFactoryHid factory = getInstance(test, false);
        if (factory instanceof XMLFileSystemTestHid.Factory) {
            XMLFileSystemTestHid.Factory f = (XMLFileSystemTestHid.Factory) factory;
            return f.createLayerSystem(testName, layers);
        }
        throw new IllegalStateException("You need to implement XMLFileSystemTestHid.Factory to use the AttributesTestHidden!");
    }
    final static boolean switchXMLSystem (FileSystem fs, Test test, URL... layers) throws IOException {
        FileSystemFactoryHid factory = getInstance(test, false);
        if (factory instanceof XMLFileSystemTestHid.Factory) {
            XMLFileSystemTestHid.Factory f = (XMLFileSystemTestHid.Factory) factory;
            return f.setXmlUrl(fs, layers);
        }
        throw new IllegalStateException("You need to implement XMLFileSystemTestHid.Factory to use the AttributesTestHidden!");
    }
      
    final static void destroyFileSystem (String testName, Test test)  throws IOException  {




        super(test);
    }


    public static void main(String args[]) {
        junit.textui.TestRunner.run(suite());
    }



    public static Test suite() {
        NbTestSuite suite = new NbTestSuite();


Lines 97-103 public abstract class TestBaseHid extend Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/TestBaseHid.java (-1 / +3 lines)
97	clearWorkDir();	97	clearWorkDir();
98	String[] resources = getResources (getName());	98	String[] resources = getResources (getName());
99	resourcePrefix = FileSystemFactoryHid.getResourcePrefix(this.getName(),this, resources);	99	resourcePrefix = FileSystemFactoryHid.getResourcePrefix(this.getName(),this, resources);
100	allTestedFS = FileSystemFactoryHid.createFileSystem(getName(),resources,this);	100	if (allTestedFS == null) {
		101	allTestedFS = FileSystemFactoryHid.createFileSystem(getName(),resources,this);
		102	}
101	if (allTestedFS != null) testedFS = allTestedFS[0];	103	if (allTestedFS != null) testedFS = allTestedFS[0];
102	// If not null, file accesses are counted through custom SecurityManager.	104	// If not null, file accesses are counted through custom SecurityManager.
103	if(accessMonitor != null) {	105	if(accessMonitor != null) {





package org.openide.filesystems;

import java.beans.PropertyVetoException;
import java.net.URL;
import junit.framework.*;
import java.io.*;
import java.util.*;
import java.util.jar.*;
import java.util.zip.*;
import java.net.*;
import org.netbeans.junit.*;
import org.openide.util.Exceptions;
//import org.openide.filesystems.hidden.*;

/**
 *
 * @author  rm111737
 * @version
 */
public class XMLFileSystemTest extends FileSystemFactoryHid
implements XMLFileSystemTestHid.Factory {

    /** Creates new XMLFileSystemTest */
    public XMLFileSystemTest(Test test) {
        super(test);
    }

    public static void main(String args[]) {
        junit.textui.TestRunner.run(suite());
    }

    public static Test suite() {

                
        return new XMLFileSystemTest(suite);
    }

    protected void destroyFileSystem(String testName) throws IOException {}
    
    protected FileSystem[] createFileSystem(String testName, String[] resources) throws IOException{
        return new FileSystem[] {TestUtilHid.createXMLFileSystem(testName, resources)};
    }

    public FileSystem createLayerSystem(String testName, URL[] layers) throws IOException {
        XMLFileSystem xfs = new XMLFileSystem();
        try {
            xfs.setXmlUrls(layers);
        } catch (PropertyVetoException ex) {
            throw (IOException)new IOException().initCause(ex);
        }
        return xfs;
    }

    public boolean setXmlUrl(org.openide.filesystems.FileSystem fs, URL[] layers) throws IOException {
        XMLFileSystem xfs = (XMLFileSystem)fs;
        try {
            xfs.setXmlUrls(layers);
        } catch (PropertyVetoException ex) {
            throw (IOException)new IOException().initCause(ex);
        }
        return true;
    }
    

    




import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class XMLFileSystemTestHid extends TestBaseHid {
    /** Factory for all filesystems that want to use TCK in this class.
     */
    public static interface Factory {
        /** Creates a filesystem representing XML files at given URLs
         *
         * @param testName name of the test
         * @param layers URLs of layers to parse
         * @return new filesystem that represents those layers
         */
        public FileSystem createLayerSystem(String testName, URL[] layers) throws IOException;

        /** Assigns new URLs to existing filesystem.
         *
         * @param fs the filesystem produced by {@link #createLayerSystem(java.lang.String, java.net.URL[])}
         * @param layers new URLs that the filesystem shall switch to
         * @return true if successful, false if this operation is not supported
         */
        public boolean setXmlUrl(FileSystem fs, URL[] layers) throws IOException;
    }

    private String[] resources = new String[] {"a/b/c"};
    FileSystem xfs = null;

    public XMLFileSystemTestHid(String testName) {
        super(testName);

        FileChangeAdapter fcl = new FileChangeAdapter();
        a.addFileChangeListener(fcl);
        
        resources = new String[] {"a/b/c","a/b1/c"};

        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, createXMLLayer().toURL())) {
            // OK, unsupported
            return;
        }
        
        FileObject b1 = xfs.findResource("a/b1");
        assertNotNull(b1);                
        assertTrue(b1.isFolder());        
    }
    
    @Override
    protected void setUp() throws Exception {
        File f = createXMLLayer();
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        this.testedFS = xfs;
        this.allTestedFS = new FileSystem[] { xfs };
        super.setUp();
        
        File f = createXMLLayer();
        xfs = new XMLFileSystem ();
        xfs.setXmlUrl(f.toURL());
        this.testedFS = xfs;
    }

    private File createXMLLayer() throws IOException {

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals ("Four bytes there", 4, fo.getSize ());
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, f2.toURL())) {
            // OK, unsupported
            return;
        }
        
        assertEquals ("Six bytes there", 6, fo.getSize ());
        

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals ("Four bytes there", 4, fo.getSize ());
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, f2.toURL())) {
            // OK, unsupported
            return;
        }
        
        assertEquals ("Six bytes there", 6, fo.getSize ());
        

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertEquals("Old value is in the attribute", "old", fo.getAttribute("value"));
        registerDefaultListener (fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, f2.toURL())) {
            // OK, unsupported
            return;
        }

        assertEquals("New value is in the attribute", "new", fo.getAttribute("value"));
        fileAttributeChangedAssert("Change in the content", 1);

        
        
        
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        
        FileObject fo = xfs.findResource("TestModule/sample.txt");
        assertEquals("Four bytes there", 4, fo.getSize());
        registerDefaultListener(fo);
        
        if (!FileSystemFactoryHid.switchXMLSystem(xfs, this, f2.toURL())) {
            // OK, unsupported
            return;
        }
        
        assertFalse("Valid no more", fo.isValid());
        assertEquals("Empty now", 0, fo.getSize());

            Thread.sleep(3000);
            assertTrue(f2.createNewFile());
        }
        xfs = FileSystemFactoryHid.createXMLSystem(getName(), this, f.toURL());
        FileObject fo = xfs.findResource ("TestModule/sample.txt");
        assertNotNull(fo);
        assertEquals(fo.lastModified().getTime(), f.lastModified());        

        return f;
    }
    

    public void testAttribute08 () throws Exception {
      URL fsURLDef = this.getClass().getResource ("data/Attributes.xml");
      assertTrue ("Cannot create XML FS for testing purposes", fsURLDef != null);
      FileSystem fs = FileSystemFactoryHid.createXMLSystem(getName(), this, fsURLDef);
      FileObject fo = fs.findResource("testMethodValue");
      assertTrue ("Cannot acces  FileObject named testMethodValue", fo != null);

      String testName = "test1";
      Object obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertTrue ("methodValue doesn't keep order ",
      obj.equals(getObjectViaMethodValue1 (fo, testName)));

      testName = "test2";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertTrue ("methodValue doesn't keep order ",
      obj.equals(getObjectViaMethodValue2 (testName, fo)));

      testName = "test3";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertTrue ("methodValue doesn't keep order ",
      obj.equals(getObjectViaMethodValue3 (fo)));

      testName = "test4";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertTrue ("methodValue doesn't keep order ",
      obj.equals(getObjectViaMethodValue4 (testName)));

      testName = "test5";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertTrue ("methodValue doesn't keep order ",
      obj.equals(getObjectViaMethodValue5 ()));

      testName = "test6";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertEquals("even works for java.util.Map", "Ahoj1", obj);

      testName = "test7";
      obj = fo.getAttribute(testName);
      assertTrue ("methodValue failed", obj != null);
      assertEquals("works for map and string", "Ahoj1test7", obj);

      testName = "testLoc";
      obj = fo.getAttribute(testName);
      assertNotNull("Value returned", obj);
      assertEquals("works for bundle key", "Hello World!", obj);
    }

    
    public void testChangeOfAnAttributeInLayerIsFiredIfThereIsRealChange() throws Exception {
        XMLFileSystem fs = new XMLFileSystem();

        public List<FileEvent> change = new ArrayList<FileEvent>();
        
        
        @Override
        public void fileRenamed(FileRenameEvent fe) {
            events.add(fe);
        }

        @Override
        public void fileAttributeChanged(FileAttributeEvent fe) {
            events.add(fe);
        }

        @Override
        public void fileFolderCreated(FileEvent fe) {
            events.add(fe);
        }

        @Override
        public void fileDeleted(FileEvent fe) {
            events.add(fe);
        }

        @Override
        public void fileDataCreated(FileEvent fe) {
            events.add(fe);
        }

        @Override
        public void fileChanged(FileEvent fe) {
            change.add(fe);
        }
        
    }
    private static String getObjectViaMethodValue1 (FileObject fo, String testName) {
        return fo.getPath()+testName;
    }

    private static String getObjectViaMethodValue1 (String testName, FileObject fo) {
        return testName+fo.getPath();
    }

    private static String getObjectViaMethodValue1 (FileObject fo) {
        return fo.getPath();
    }

    private static String getObjectViaMethodValue1 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue1 () {
        return "";
    }
///
    private static String getObjectViaMethodValue2 (String testName, FileObject fo) {
        return testName+fo.getPath();
    }

    private static String getObjectViaMethodValue2 (FileObject fo) {
        return fo.getPath();
    }

    private static String getObjectViaMethodValue2 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue2 () {
        return "";
    }
///
    private static String getObjectViaMethodValue3 (FileObject fo) {
        return fo.getPath();
    }

    private static String getObjectViaMethodValue3 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue3 () {
        return "";
    }
///
    private static String getObjectViaMethodValue4 (String testName) {
        return testName;
    }

    private static String getObjectViaMethodValue4 () {
        return "";
    }
///
    private static String getObjectViaMethodValue5 () {
        return "";
    }

    private static Object getObjectViaMethodValue6 (Map attrs) {
        try {
            attrs.keySet().iterator().remove();
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        try {
            attrs.put("value1", "nothing");
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }
        try {
            attrs.remove("value1");
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }


        return attrs.get("value1");
    }
    private static Object getObjectViaMethodValue7 (Map<String,Object> attrs, String attrName) {
        assertEquals(9, attrs.keySet().size());
        try {
            attrs.entrySet().remove(null);
            return "UnsupportedOperationException";
        } catch (UnsupportedOperationException ex) {
            // ok
        }


        return attrs.get("value1") + attrName;
    }
    
}




<!DOCTYPE filesystem PUBLIC '-//NetBeans//DTD Filesystem 1.1//EN' 'http://www.netbeans.org/dtds/filesystem-1_1.dtd'>
<filesystem>
    <folder name="testMethodValue"> 
        <attr name="test1" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue1"/>
        <attr name="test2" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue2"/>
        <attr name="test3" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue3"/>
        <attr name="test4" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue4"/>
        <attr name="test5" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue5"/>
        <attr name="test6" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue6"/>
        <attr name="test7" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue7"/>
                
        <attr name="value1" stringvalue="Ahoj1"/>
        <attr name="testLoc" bundlevalue="org.openide.filesystems.data.TestBundle#AHOJ"/>
    </folder>
</filesystem>




# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
# 
# Copyright 2008 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]"
# 
# 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 2008 Sun Microsystems, Inc.

AHOJ=Hello World!


Return to bug 138076

Lines 41-52 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/AttributesTestHidden.java (-147 / +1 lines)
41		41
42	package org.openide.filesystems;	42	package org.openide.filesystems;
43		43
44	import junit.framework.*;
45	//import org.openide.filesystems.hidden.*;
46		44
47	import java.util.*;	45	import java.util.*;
48	import java.io.*;	46	import java.io.*;
49	import java.net.URL;
50		47
51	/**	48	/**
52	*	49	*
Lines 55-60 import java.net.URL; Link Here
55	*	52	*
56	*/	53	*/
57	public class AttributesTestHidden extends TestBaseHid {	54	public class AttributesTestHidden extends TestBaseHid {
		55
58	static final String TEST_ERR = "Not the tested code, but this test contains errors";	56	static final String TEST_ERR = "Not the tested code, but this test contains errors";
59	static final String COMMON_ATTR_STRING = "testAttribute";	57	static final String COMMON_ATTR_STRING = "testAttribute";
60		58
Lines 245-299 public class AttributesTestHidden extend Link Here
245	assertTrue ("There was not found expected key: " + COMMON_ATTR_STRING +" in .nbattrs",content.indexOf("name=\""+COMMON_ATTR_STRING) != -1 );//	243	assertTrue ("There was not found expected key: " + COMMON_ATTR_STRING +" in .nbattrs",content.indexOf("name=\""+COMMON_ATTR_STRING) != -1 );//
246	}	244	}
247		245
248
249	public void testAttribute08 () throws Exception {
250	URL fsURLDef = this.getClass().getResource ("data/Attributes.xml");
251	assertTrue ("Cannot create XML FS for testing purposes", fsURLDef != null);
252	FileSystem fs = new XMLFileSystem (fsURLDef);
253	FileObject fo = fs.findResource("testMethodValue");
254	assertTrue ("Cannot acces FileObject named testMethodValue", fo != null);
255
256	String testName = "test1";
257	Object obj = fo.getAttribute(testName);
258	assertTrue ("methodValue failed", obj != null);
259	assertTrue ("methodValue doesn't keep order ",
260	obj.equals(getObjectViaMethodValue1 (fo, testName)));
261
262	testName = "test2";
263	obj = fo.getAttribute(testName);
264	assertTrue ("methodValue failed", obj != null);
265	assertTrue ("methodValue doesn't keep order ",
266	obj.equals(getObjectViaMethodValue2 (testName, fo)));
267
268	testName = "test3";
269	obj = fo.getAttribute(testName);
270	assertTrue ("methodValue failed", obj != null);
271	assertTrue ("methodValue doesn't keep order ",
272	obj.equals(getObjectViaMethodValue3 (fo)));
273
274	testName = "test4";
275	obj = fo.getAttribute(testName);
276	assertTrue ("methodValue failed", obj != null);
277	assertTrue ("methodValue doesn't keep order ",
278	obj.equals(getObjectViaMethodValue4 (testName)));
279
280	testName = "test5";
281	obj = fo.getAttribute(testName);
282	assertTrue ("methodValue failed", obj != null);
283	assertTrue ("methodValue doesn't keep order ",
284	obj.equals(getObjectViaMethodValue5 ()));
285
286	testName = "test6";
287	obj = fo.getAttribute(testName);
288	assertTrue ("methodValue failed", obj != null);
289	assertEquals("even works for java.util.Map", "Ahoj1", obj);
290
291	testName = "test7";
292	obj = fo.getAttribute(testName);
293	assertTrue ("methodValue failed", obj != null);
294	assertEquals("works for map and string", "Ahoj1test7", obj);
295	}
296
297	public void testAttribute09 () throws IOException {	246	public void testAttribute09 () throws IOException {
298	assertTrue (TEST_ERR,testedFS != null);	247	assertTrue (TEST_ERR,testedFS != null);
299	if (testedFS.isReadOnly ()) return;	248	if (testedFS.isReadOnly ()) return;
Lines 322-422 public class AttributesTestHidden extend Link Here
322	}	271	}
323	}	272	}
324		273
325	private static String getObjectViaMethodValue1 (FileObject fo, String testName) {
326	return fo.getPath()+testName;
327	}
328
329	private static String getObjectViaMethodValue1 (String testName, FileObject fo) {
330	return testName+fo.getPath();
331	}
332
333	private static String getObjectViaMethodValue1 (FileObject fo) {
334	return fo.getPath();
335	}
336
337	private static String getObjectViaMethodValue1 (String testName) {
338	return testName;
339	}
340
341	private static String getObjectViaMethodValue1 () {
342	return "";
343	}
344	///
345	private static String getObjectViaMethodValue2 (String testName, FileObject fo) {
346	return testName+fo.getPath();
347	}
348
349	private static String getObjectViaMethodValue2 (FileObject fo) {
350	return fo.getPath();
351	}
352
353	private static String getObjectViaMethodValue2 (String testName) {
354	return testName;
355	}
356
357	private static String getObjectViaMethodValue2 () {
358	return "";
359	}
360	///
361	private static String getObjectViaMethodValue3 (FileObject fo) {
362	return fo.getPath();
363	}
364
365	private static String getObjectViaMethodValue3 (String testName) {
366	return testName;
367	}
368
369	private static String getObjectViaMethodValue3 () {
370	return "";
371	}
372	///
373	private static String getObjectViaMethodValue4 (String testName) {
374	return testName;
375	}
376
377	private static String getObjectViaMethodValue4 () {
378	return "";
379	}
380	///
381	private static String getObjectViaMethodValue5 () {
382	return "";
383	}
384
385	private static Object getObjectViaMethodValue6 (Map attrs) {
386	try {
387	attrs.keySet().iterator().remove();
388	return "UnsupportedOperationException";
389	} catch (UnsupportedOperationException ex) {
390	// ok
391	}
392	try {
393	attrs.put("value1", "nothing");
394	return "UnsupportedOperationException";
395	} catch (UnsupportedOperationException ex) {
396	// ok
397	}
398	try {
399	attrs.remove("value1");
400	return "UnsupportedOperationException";
401	} catch (UnsupportedOperationException ex) {
402	// ok
403	}
404
405
406	return attrs.get("value1");
407	}
408	private static Object getObjectViaMethodValue7 (Map<String,Object> attrs, String attrName) {
409	assertEquals(8, attrs.keySet().size());
410	try {
411	attrs.entrySet().remove(null);
412	return "UnsupportedOperationException";
413	} catch (UnsupportedOperationException ex) {
414	// ok
415	}
416
417
418	return attrs.get("value1") + attrName;
419	}
420		274
421	private String basicAttributeTest (String attrName, String attrValue) throws IOException {	275	private String basicAttributeTest (String attrName, String attrValue) throws IOException {
422	FileObject foTested = testedFS.getRoot ();	276	FileObject foTested = testedFS.getRoot ();

Lines 41-51 Link Here

(-)a/core.startup/test/unit/src/org/netbeans/core/startup/layers/BinaryFSTest.java (-4 / +14 lines)
41		41
42	package org.netbeans.core.startup.layers;	42	package org.netbeans.core.startup.layers;
43		43
44	import java.io.ByteArrayOutputStream;
45	import java.io.File;	44	import java.io.File;
46	import java.io.IOException;	45	import java.io.IOException;
47	import java.net.URL;	46	import java.net.URL;
48	import java.nio.ByteBuffer;
49	import java.util.Arrays;	47	import java.util.Arrays;
50	import junit.framework.Test;	48	import junit.framework.Test;
51	import org.netbeans.junit.NbTestSuite;	49	import org.netbeans.junit.NbTestSuite;
Lines 56-67 import org.openide.filesystems.FileSyste Link Here
56	import org.openide.filesystems.FileSystemTestHid;	54	import org.openide.filesystems.FileSystemTestHid;
57	import org.openide.filesystems.TestUtilHid;	55	import org.openide.filesystems.TestUtilHid;
58	import org.openide.filesystems.XMLFileSystem;	56	import org.openide.filesystems.XMLFileSystem;
		57	import org.openide.filesystems.XMLFileSystemTestHid;
59		58
60	/**	59	/**
61	*	60	*
62	* @author Radek Matous	61	* @author Radek Matous
63	*/	62	*/
64	public class BinaryFSTest extends FileSystemFactoryHid {	63	public class BinaryFSTest extends FileSystemFactoryHid
		64	implements XMLFileSystemTestHid.Factory {
65	public BinaryFSTest(Test test) {	65	public BinaryFSTest(Test test) {
66	super(test);	66	super(test);
67	}	67	}
Lines 71-76 public class BinaryFSTest extends FileSy Link Here
71	suite.addTestSuite(FileSystemTestHid.class);	71	suite.addTestSuite(FileSystemTestHid.class);
72	suite.addTestSuite(FileObjectTestHid.class);	72	suite.addTestSuite(FileObjectTestHid.class);
73	suite.addTestSuite(AttributesTestHidden.class);	73	suite.addTestSuite(AttributesTestHidden.class);
		74	suite.addTestSuite(XMLFileSystemTestHid.class);
74		75
75	return new BinaryFSTest(suite);	76	return new BinaryFSTest(suite);
76	}	77	}
Lines 88-92 public class BinaryFSTest extends FileSy Link Here
88	String workDirProperty = System.getProperty("workdir");//NOI18N	89	String workDirProperty = System.getProperty("workdir");//NOI18N
89	workDirProperty = (workDirProperty != null) ? workDirProperty : System.getProperty("java.io.tmpdir");//NOI18N	90	workDirProperty = (workDirProperty != null) ? workDirProperty : System.getProperty("java.io.tmpdir");//NOI18N
90	return new File(workDirProperty);	91	return new File(workDirProperty);
91	}	92	}
		93
		94	public FileSystem createLayerSystem(String testName, URL[] layers) throws IOException {
		95	LayerCacheManager bm = LayerCacheManager.manager(true);
		96	return BinaryCacheManagerTest.store(bm, Arrays.asList(layers));
		97	}
		98
		99	public boolean setXmlUrl(FileSystem fs, URL[] layers) throws IOException {
		100	return false;
		101	}
92	}	102	}

Lines 45-53 import org.netbeans.junit.*; Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/FileSystemFactoryHid.java (-1 / +22 lines)
45	import org.netbeans.junit.*;	45	import org.netbeans.junit.*;
46		46
47	import java.io.*;	47	import java.io.*;
		48	import java.net.URL;
48	import java.util.*;	49	import java.util.*;
49		50
50	import org.openide.filesystems.*;
51		51
52		52
53	/**	53	/**
Lines 77-82 public abstract class FileSystemFactoryH Link Here
77	* @return array of FileSystems that should be tested in test named: "testName"*/	77	* @return array of FileSystems that should be tested in test named: "testName"*/
78	final static FileSystem[] createFileSystem (String testName,String[] resources, Test test) throws IOException {	78	final static FileSystem[] createFileSystem (String testName,String[] resources, Test test) throws IOException {
79	return getInstance (test,true).createFileSystem(testName, resources);	79	return getInstance (test,true).createFileSystem(testName, resources);
		80	}
		81
		82	/**
		83	* Intended to allow prepare tested environment for each individual test.
		84	* @param testName name of test
		85	* @return array of FileSystems that should be tested in test named: "testName"*/
		86	final static FileSystem createXMLSystem (String testName, Test test, URL... layers) throws IOException {
		87	FileSystemFactoryHid factory = getInstance(test, false);
		88	if (factory instanceof XMLFileSystemTestHid.Factory) {
		89	XMLFileSystemTestHid.Factory f = (XMLFileSystemTestHid.Factory) factory;
		90	return f.createLayerSystem(testName, layers);
		91	}
		92	throw new IllegalStateException("You need to implement XMLFileSystemTestHid.Factory to use the AttributesTestHidden!");
		93	}
		94	final static boolean switchXMLSystem (FileSystem fs, Test test, URL... layers) throws IOException {
		95	FileSystemFactoryHid factory = getInstance(test, false);
		96	if (factory instanceof XMLFileSystemTestHid.Factory) {
		97	XMLFileSystemTestHid.Factory f = (XMLFileSystemTestHid.Factory) factory;
		98	return f.setXmlUrl(fs, layers);
		99	}
		100	throw new IllegalStateException("You need to implement XMLFileSystemTestHid.Factory to use the AttributesTestHidden!");
80	}	101	}
81		102
82	final static void destroyFileSystem (String testName, Test test) throws IOException {	103	final static void destroyFileSystem (String testName, Test test) throws IOException {

Lines 11-24 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/data/Attributes.xml (-8 / +8 lines)
11	<!DOCTYPE filesystem PUBLIC '-//NetBeans//DTD Filesystem 1.1//EN' 'http://www.netbeans.org/dtds/filesystem-1_1.dtd'>	11	<!DOCTYPE filesystem PUBLIC '-//NetBeans//DTD Filesystem 1.1//EN' 'http://www.netbeans.org/dtds/filesystem-1_1.dtd'>
12	<filesystem>	12	<filesystem>
13	<folder name="testMethodValue">	13	<folder name="testMethodValue">
14	<attr name="test1" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue1"/>	14	<attr name="test1" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue1"/>
15	<attr name="test2" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue2"/>	15	<attr name="test2" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue2"/>
16	<attr name="test3" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue3"/>	16	<attr name="test3" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue3"/>
17	<attr name="test4" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue4"/>	17	<attr name="test4" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue4"/>
18	<attr name="test5" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue5"/>	18	<attr name="test5" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue5"/>
19	<attr name="test6" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue6"/>	19	<attr name="test6" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue6"/>
20	<attr name="test7" methodvalue="org.openide.filesystems.AttributesTestHidden.getObjectViaMethodValue7"/>	20	<attr name="test7" methodvalue="org.openide.filesystems.XMLFileSystemTestHid.getObjectViaMethodValue7"/>
21
22	<attr name="value1" stringvalue="Ahoj1"/>	21	<attr name="value1" stringvalue="Ahoj1"/>
		22	<attr name="testLoc" bundlevalue="org.openide.filesystems.data.TestBundle#AHOJ"/>
23	</folder>	23	</folder>
24	</filesystem>	24	</filesystem>

Added Link Here

(-)c06fe6e89701 (+39 lines)
1	# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
2	#
3	# Copyright 2008 Sun Microsystems, Inc. All rights reserved.
4	#
5	# The contents of this file are subject to the terms of either the GNU
6	# General Public License Version 2 only ("GPL") or the Common
7	# Development and Distribution License("CDDL") (collectively, the
8	# "License"). You may not use this file except in compliance with the
9	# License. You can obtain a copy of the License at
10	# http://www.netbeans.org/cddl-gplv2.html
11	# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
12	# specific language governing permissions and limitations under the
13	# License. When distributing the software, include this License Header
14	# Notice in each file and include the License file at
15	# nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
16	# particular file as subject to the "Classpath" exception as provided
17	# by Sun in the GPL Version 2 section of the License file that
18	# accompanied this code. If applicable, add the following below the
19	# License Header, with the fields enclosed by brackets [] replaced by
20	# your own identifying information:
21	# "Portions Copyrighted [year] [name of copyright owner]"
22	#
23	# If you wish your version of this file to be governed by only the CDDL
24	# or only the GPL Version 2, indicate your decision by adding
25	# "[Contributor] elects to include this software in this distribution
26	# under the [CDDL or GPL Version 2] license." If you do not indicate a
27	# single choice of license, a recipient has the option to distribute
28	# your version of this file under either the CDDL, the GPL Version 2 or
29	# to extend the choice of license to its licensees as provided above.
30	# However, if you add GPL Version 2 code and therefore, elected the GPL
31	# Version 2 license, then the option applies only if the new code is
32	# made subject to such option by the copyright holder.
33	#
34	# Contributor(s):
35	#
36	# Portions Copyrighted 2008 Sun Microsystems, Inc.
37
38	AHOJ=Hello World!
39