001    /*
002     * Copyright 2005,2009 Ivan SZKIBA
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *      http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    package org.ini4j;
017    
018    import org.ini4j.sample.Dwarfs;
019    
020    import org.ini4j.test.DwarfsData;
021    import org.ini4j.test.Helper;
022    
023    import static org.junit.Assert.assertArrayEquals;
024    import static org.junit.Assert.assertNotNull;
025    import static org.junit.Assert.assertSame;
026    import static org.junit.Assert.fail;
027    
028    import org.junit.Test;
029    
030    import java.io.ByteArrayOutputStream;
031    import java.io.File;
032    import java.io.FileInputStream;
033    import java.io.FileNotFoundException;
034    import java.io.FileOutputStream;
035    import java.io.IOException;
036    import java.io.InputStream;
037    import java.io.InputStreamReader;
038    import java.io.StringReader;
039    
040    public class RegTest extends Ini4jCase
041    {
042        private static final String DWARFS_PATH = Helper.DWARFS_REG_PATH + "\\dwarfs\\";
043    
044        @Test public void proba() throws Exception
045        {
046        }
047    
048        @Test public void testDwarfs() throws Exception
049        {
050            Reg reg = Helper.loadDwarfsReg();
051            Dwarfs dwarfs = reg.as(Dwarfs.class, DWARFS_PATH);
052    
053            assertNotNull(dwarfs);
054            Helper.assertEquals(DwarfsData.dwarfs, dwarfs);
055        }
056    
057        @Test public void testInvalidFileFormatException() throws Exception
058        {
059            try
060            {
061                new Reg(Helper.getResourceReader(Helper.DWARFS_INI));
062                missing(InvalidFileFormatException.class);
063            }
064            catch (InvalidFileFormatException x)
065            {
066                //
067            }
068        }
069    
070        @Test public void testIsWindwos()
071        {
072            assertEquals(isWindows(), Reg.isWindows());
073        }
074    
075        @Test public void testLoad() throws Exception
076        {
077            Reg r1 = new Reg(new InputStreamReader(Helper.getResourceStream(Helper.DWARFS_REG), "UnicodeLittle"));
078            Reg r2 = new Reg(Helper.getResourceStream(Helper.DWARFS_REG));
079            Reg r3 = new Reg(Helper.getResourceURL(Helper.DWARFS_REG));
080            File f = Helper.getSourceFile(Helper.DWARFS_REG);
081            Reg r4 = new Reg(f);
082            Reg r5 = new Reg();
083    
084            r5.setFile(f);
085            r5.load();
086            Helper.assertEquals(DwarfsData.dwarfs, r1.as(Dwarfs.class, DWARFS_PATH));
087            Helper.assertEquals(DwarfsData.dwarfs, r2.as(Dwarfs.class, DWARFS_PATH));
088            Helper.assertEquals(DwarfsData.dwarfs, r3.as(Dwarfs.class, DWARFS_PATH));
089            Helper.assertEquals(DwarfsData.dwarfs, r4.as(Dwarfs.class, DWARFS_PATH));
090            Helper.assertEquals(DwarfsData.dwarfs, r5.as(Dwarfs.class, DWARFS_PATH));
091            assertSame(f, r4.getFile());
092        }
093    
094        @Test public void testLoadFileNotFoundException() throws Exception
095        {
096            Reg reg = new Reg();
097    
098            try
099            {
100                reg.load();
101                missing(FileNotFoundException.class);
102            }
103            catch (FileNotFoundException x)
104            {
105                //
106            }
107        }
108    
109        @Test public void testLoadSave() throws Exception
110        {
111            Reg reg = new Reg(Helper.getResourceURL(Helper.TEST_REG));
112    
113            checkLoadSave(Helper.TEST_REG, reg);
114        }
115    
116        @Test public void testMissingVersion() throws Exception
117        {
118            try
119            {
120                new Reg(new StringReader("\r\n\r\n[section]\r\n\"option\"=\"value\""));
121                missing(InvalidFileFormatException.class);
122            }
123            catch (InvalidFileFormatException x)
124            {
125                //
126            }
127        }
128    
129        @Test public void testNonWindwosExec() throws Exception
130        {
131            if (isSkip(isWindows(), "testNonWindwosExec"))
132            {
133                return;
134            }
135    
136            Reg reg = new Reg();
137    
138            reg.exec(new String[] { "/bin/true" });
139            try
140            {
141                reg.exec(new String[] { "/bin/ls", "no such file" });
142                fail("IOException expected");
143            }
144            catch (IOException x)
145            {
146                assert true;
147            }
148        }
149    
150        @Test public void testReadException() throws Exception
151        {
152            if (!isWindows())
153            {
154                try
155                {
156                    new Reg(Reg.Hive.HKEY_CURRENT_USER.toString());
157                    fail("missing UnsupportedOperationException");
158                }
159                catch (UnsupportedOperationException x)
160                {
161                    assert true;
162                }
163            }
164            else
165            {
166                try
167                {
168                    new Reg("no such key");
169                    fail("missing IOException");
170                }
171                catch (IOException x)
172                {
173                    assert true;
174                }
175            }
176        }
177    
178        @Test public void testReadWrite() throws Exception
179        {
180            if (isSkip(!isWindows(), "testReadWrite"))
181            {
182                return;
183            }
184    
185            Reg reg = Helper.loadDwarfsReg();
186    
187            reg.write();
188            Reg dup = new Reg(Helper.DWARFS_REG_PATH);
189    
190            Helper.assertEquals(reg.get(Helper.DWARFS_REG_PATH), dup.get(Helper.DWARFS_REG_PATH));
191            Dwarfs dwarfs = dup.as(Dwarfs.class, DWARFS_PATH);
192    
193            assertNotNull(dwarfs);
194            Helper.assertEquals(DwarfsData.dwarfs, dwarfs);
195        }
196    
197        @Test public void testStore() throws Exception
198        {
199            Reg reg = Helper.loadDwarfsReg();
200            File tmp = File.createTempFile(Reg.TMP_PREFIX, Reg.DEFAULT_SUFFIX);
201    
202            tmp.deleteOnExit();
203            reg.setFile(tmp);
204            reg.store();
205            reg = new Reg(tmp);
206            Helper.assertEquals(DwarfsData.dwarfs, reg.as(Dwarfs.class, DWARFS_PATH));
207            tmp.delete();
208        }
209    
210        @Test public void testStoreFileNotFoundException() throws Exception
211        {
212            try
213            {
214                new Reg().store();
215                missing(FileNotFoundException.class);
216            }
217            catch (FileNotFoundException x)
218            {
219                //
220            }
221        }
222    
223        @Test public void testUnsupportedOperatingSystem() throws Exception
224        {
225            if (isSkip(isWindows(), "testUnsupportedOperatingSystem"))
226            {
227                return;
228            }
229    
230            Reg reg = new Reg();
231    
232            try
233            {
234                reg.read(Helper.DWARFS_REG_PATH);
235                fail("UnsupportedOperationException expected");
236            }
237            catch (UnsupportedOperationException x)
238            {
239                assert true;
240            }
241    
242            try
243            {
244                reg.write();
245                fail("UnsupportedOperationException expected");
246            }
247            catch (UnsupportedOperationException x)
248            {
249                assert true;
250            }
251        }
252    
253        private boolean isSkip(boolean flag, String testName)
254        {
255            if (!flag)
256            {
257                System.out.println("Skipping " + getClass().getName() + '#' + testName);
258            }
259    
260            return flag;
261        }
262    
263        private boolean isWindows()
264        {
265            String family = System.getProperty("os.family");
266    
267            return (family != null) && family.equals("windows");
268        }
269    
270        private void checkLoadSave(String path, Reg reg) throws Exception
271        {
272            File tmp = File.createTempFile(Reg.TMP_PREFIX, Reg.DEFAULT_SUFFIX);
273    
274            tmp.deleteOnExit();
275            reg.store(new FileOutputStream(tmp));
276            assertArrayEquals(read(Helper.getResourceStream(path)), read(new FileInputStream(tmp)));
277        }
278    
279        private byte[] read(InputStream input) throws Exception
280        {
281            ByteArrayOutputStream out = new ByteArrayOutputStream();
282            byte[] buff = new byte[81912];
283            int n;
284    
285            while ((n = input.read(buff)) >= 0)
286            {
287                out.write(buff, 0, n);
288            }
289    
290            return out.toByteArray();
291        }
292    }