Modified: poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/ObjectShape.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/ObjectShape.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/ObjectShape.java (original) +++ poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/ObjectShape.java Wed Sep 20 20:32:59 2023 @@ -113,7 +113,7 @@ public interface ObjectShape< final DirectoryNode root = poifs.getRoot(); String entryName = null; for (String n : names) { - if (root.hasEntry(n)) { + if (root.hasEntryCaseInsensitive(n)) { entryName = n; break; }
Modified: poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/SlideShowFactory.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/SlideShowFactory.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/SlideShowFactory.java (original) +++ poi/trunk/poi/src/main/java/org/apache/poi/sl/usermodel/SlideShowFactory.java Wed Sep 20 20:32:59 2023 @@ -126,7 +126,7 @@ public final class SlideShowFactory { */ public static SlideShow<?,?> create(final DirectoryNode root, String password) throws IOException { // Encrypted OOXML files go inside OLE2 containers, is this one? - if (root.hasEntry(Decryptor.DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE)) { + if (root.hasEntryCaseInsensitive(Decryptor.DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE)) { return wp(FileMagic.OOXML, w -> w.create(root, password)); } else { return wp(FileMagic.OLE2, w -> w.create(root, password)); @@ -200,7 +200,7 @@ public final class SlideShowFactory { POIFSFileSystem poifs = new POIFSFileSystem(is); DirectoryNode root = poifs.getRoot(); - boolean isOOXML = root.hasEntry(DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE); + boolean isOOXML = root.hasEntryCaseInsensitive(DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE); return wp(isOOXML ? FileMagic.OOXML : fm, w -> w.create(poifs.getRoot(), password)); } @@ -274,7 +274,7 @@ public final class SlideShowFactory { final boolean ooxmlEnc; try (POIFSFileSystem fs = new POIFSFileSystem(file, true)) { DirectoryNode root = fs.getRoot(); - ooxmlEnc = root.hasEntry(Decryptor.DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE); + ooxmlEnc = root.hasEntryCaseInsensitive(Decryptor.DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE); } return wp(ooxmlEnc ? FileMagic.OOXML : fm, w -> w.create(file, password, readOnly)); } else { Modified: poi/trunk/poi/src/main/java/org/apache/poi/ss/extractor/EmbeddedExtractor.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/main/java/org/apache/poi/ss/extractor/EmbeddedExtractor.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/main/java/org/apache/poi/ss/extractor/EmbeddedExtractor.java (original) +++ poi/trunk/poi/src/main/java/org/apache/poi/ss/extractor/EmbeddedExtractor.java Wed Sep 20 20:32:59 2023 @@ -213,7 +213,7 @@ public class EmbeddedExtractor implement @Override public boolean canExtract(DirectoryNode dn) { ClassID clsId = dn.getStorageClsid(); - return (ClassIDPredefined.PDF.equals(clsId) || dn.hasEntry("CONTENTS")); + return (ClassIDPredefined.PDF.equals(clsId) || dn.hasEntryCaseInsensitive("CONTENTS")); } @Override @@ -273,7 +273,7 @@ public class EmbeddedExtractor implement static class OOXMLExtractor extends EmbeddedExtractor { @Override public boolean canExtract(DirectoryNode dn) { - return dn.hasEntry("package"); + return dn.hasEntryCaseInsensitive("package"); } @Override @@ -312,14 +312,14 @@ public class EmbeddedExtractor implement ClassIDPredefined clsId = ClassIDPredefined.lookup(dn.getStorageClsid()); return (ClassIDPredefined.EXCEL_V7 == clsId || ClassIDPredefined.EXCEL_V8 == clsId - || dn.hasEntry("Workbook") /*...*/); + || dn.hasEntryCaseInsensitive("Workbook") /*...*/); } protected boolean canExtractWord(DirectoryNode dn) { ClassIDPredefined clsId = ClassIDPredefined.lookup(dn.getStorageClsid()); return (ClassIDPredefined.WORD_V7 == clsId || ClassIDPredefined.WORD_V8 == clsId - || dn.hasEntry("WordDocument")); + || dn.hasEntryCaseInsensitive("WordDocument")); } @Override Modified: poi/trunk/poi/src/main/java/org/apache/poi/ss/usermodel/WorkbookFactory.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/main/java/org/apache/poi/ss/usermodel/WorkbookFactory.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/main/java/org/apache/poi/ss/usermodel/WorkbookFactory.java (original) +++ poi/trunk/poi/src/main/java/org/apache/poi/ss/usermodel/WorkbookFactory.java Wed Sep 20 20:32:59 2023 @@ -150,7 +150,7 @@ public final class WorkbookFactory { */ public static Workbook create(final DirectoryNode root, String password) throws IOException { // Encrypted OOXML files go inside OLE2 containers, is this one? - if (root.hasEntry(DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE)) { + if (root.hasEntryCaseInsensitive(DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE)) { return wp(FileMagic.OOXML, w -> w.create(root, password)); } else { return wp(FileMagic.OLE2, w -> w.create(root, password)); @@ -230,7 +230,7 @@ public final class WorkbookFactory { POIFSFileSystem poifs = new POIFSFileSystem(is); DirectoryNode root = poifs.getRoot(); - boolean isOOXML = root.hasEntry(DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE); + boolean isOOXML = root.hasEntryCaseInsensitive(DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE); return wp(isOOXML ? FileMagic.OOXML : fm, w -> w.create(root, password)); } @@ -313,7 +313,7 @@ public final class WorkbookFactory { final boolean ooxmlEnc; try (POIFSFileSystem fs = new POIFSFileSystem(file, true)) { DirectoryNode root = fs.getRoot(); - ooxmlEnc = root.hasEntry(DEFAULT_POIFS_ENTRY) || root.hasEntry(OOXML_PACKAGE); + ooxmlEnc = root.hasEntryCaseInsensitive(DEFAULT_POIFS_ENTRY) || root.hasEntryCaseInsensitive(OOXML_PACKAGE); } return wp(ooxmlEnc ? FileMagic.OOXML : fm, w -> w.create(file, password, readOnly)); } else { Modified: poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestReadAllFiles.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestReadAllFiles.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestReadAllFiles.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestReadAllFiles.java Wed Sep 20 20:32:59 2023 @@ -154,7 +154,7 @@ class TestReadAllFiles { * If there is a document summry information stream, read it from * the POI filesystem. */ - if (dir.hasEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME)) { + if (dir.hasEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME)) { final DocumentSummaryInformation dsi = TestWriteWellKnown.getDocumentSummaryInformation(poifs); assertNotNull(dsi); Modified: poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWrite.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWrite.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWrite.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWrite.java Wed Sep 20 20:32:59 2023 @@ -447,8 +447,8 @@ class TestWrite { DirectoryEntry root = fs.getRoot(); // Read the properties in there - DocumentNode sinfDoc = (DocumentNode) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); - DocumentNode dinfDoc = (DocumentNode) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode sinfDoc = (DocumentNode) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode dinfDoc = (DocumentNode) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream = new DocumentInputStream(sinfDoc); SummaryInformation sinf = (SummaryInformation) PropertySetFactory.create(sinfStream); @@ -479,8 +479,8 @@ class TestWrite { // Check it didn't get changed - sinfDoc = (DocumentNode) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); - dinfDoc = (DocumentNode) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + sinfDoc = (DocumentNode) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); + dinfDoc = (DocumentNode) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream2 = new DocumentInputStream(sinfDoc); sinf = (SummaryInformation) PropertySetFactory.create(sinfStream2); @@ -503,8 +503,8 @@ class TestWrite { DirectoryEntry root = fs.getRoot(); // Read the properties in once more - DocumentNode sinfDoc = (DocumentNode)root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); - DocumentNode dinfDoc = (DocumentNode)root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode sinfDoc = (DocumentNode)root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode dinfDoc = (DocumentNode)root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream3 = new DocumentInputStream(sinfDoc); SummaryInformation sinf = (SummaryInformation)PropertySetFactory.create(sinfStream3); @@ -533,8 +533,8 @@ class TestWrite { // Check that the filesystem can give us back the same bytes - sinfDoc = (DocumentNode)root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); - dinfDoc = (DocumentNode)root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + sinfDoc = (DocumentNode)root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); + dinfDoc = (DocumentNode)root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream4 = new DocumentInputStream(sinfDoc); byte[] sinfData = IOUtils.toByteArray(sinfStream4); @@ -581,13 +581,13 @@ class TestWrite { // Read them back in again - sinfDoc = (DocumentNode)root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); + sinfDoc = (DocumentNode)root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream6 = new DocumentInputStream(sinfDoc); sinf = (SummaryInformation)PropertySetFactory.create(sinfStream6); sinfStream6.close(); assertEquals(131077, sinf.getOSVersion()); - dinfDoc = (DocumentNode)root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + dinfDoc = (DocumentNode)root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream dinfStream6 = new DocumentInputStream(dinfDoc); dinf = (DocumentSummaryInformation)PropertySetFactory.create(dinfStream6); dinfStream6.close(); @@ -609,13 +609,13 @@ class TestWrite { DirectoryEntry root = fs.getRoot(); // Re-check on load - DocumentNode sinfDoc = (DocumentNode) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode sinfDoc = (DocumentNode) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); InputStream sinfStream7 = new DocumentInputStream(sinfDoc); SummaryInformation sinf = (SummaryInformation) PropertySetFactory.create(sinfStream7); sinfStream7.close(); assertEquals(131077, sinf.getOSVersion()); - DocumentNode dinfDoc = (DocumentNode) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME); + DocumentNode dinfDoc = (DocumentNode) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME); InputStream dinfStream7 = new DocumentInputStream(dinfDoc); DocumentSummaryInformation dinf = (DocumentSummaryInformation) PropertySetFactory.create(dinfStream7); dinfStream7.close(); Modified: poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWriteWellKnown.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWriteWellKnown.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWriteWellKnown.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hpsf/basic/TestWriteWellKnown.java Wed Sep 20 20:32:59 2023 @@ -494,7 +494,7 @@ class TestWriteWellKnown { static DocumentSummaryInformation getDocumentSummaryInformation(POIFSFileSystem poifs) throws IOException, NoPropertySetStreamException, UnexpectedPropertySetTypeException { - if (!poifs.getRoot().hasEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME)) { + if (!poifs.getRoot().hasEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME)) { return null; } Modified: poi/trunk/poi/src/test/java/org/apache/poi/hssf/extractor/TestExcelExtractor.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hssf/extractor/TestExcelExtractor.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hssf/extractor/TestExcelExtractor.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hssf/extractor/TestExcelExtractor.java Wed Sep 20 20:32:59 2023 @@ -252,9 +252,9 @@ final class TestExcelExtractor { try { fs = new POIFSFileSystem(POIDataSamples.getDocumentInstance().getFile("word_with_embeded.doc")); - DirectoryNode objPool = (DirectoryNode) fs.getRoot().getEntry("ObjectPool"); - DirectoryNode dirA = (DirectoryNode) objPool.getEntry("_1269427460"); - DirectoryNode dirB = (DirectoryNode) objPool.getEntry("_1269427461"); + DirectoryNode objPool = (DirectoryNode) fs.getRoot().getEntryCaseInsensitive("ObjectPool"); + DirectoryNode dirA = (DirectoryNode) objPool.getEntryCaseInsensitive("_1269427460"); + DirectoryNode dirB = (DirectoryNode) objPool.getEntryCaseInsensitive("_1269427461"); wbA = new HSSFWorkbook(dirA, fs, true); exA = new ExcelExtractor(wbA); @@ -287,8 +287,8 @@ final class TestExcelExtractor { try { fs = new POIFSFileSystem(ssSamples.getFile("excel_with_embeded.xls")); - DirectoryNode dirA = (DirectoryNode) fs.getRoot().getEntry("MBD0000A3B5"); - DirectoryNode dirB = (DirectoryNode) fs.getRoot().getEntry("MBD0000A3B4"); + DirectoryNode dirA = (DirectoryNode) fs.getRoot().getEntryCaseInsensitive("MBD0000A3B5"); + DirectoryNode dirB = (DirectoryNode) fs.getRoot().getEntryCaseInsensitive("MBD0000A3B4"); wbA = new HSSFWorkbook(dirA, fs, true); wbB = new HSSFWorkbook(dirB, fs, true); Modified: poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestBugs.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestBugs.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestBugs.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestBugs.java Wed Sep 20 20:32:59 2023 @@ -2451,7 +2451,7 @@ final class TestBugs extends BaseTestBug try (POIFSFileSystem poifs = new POIFSFileSystem(HSSFTestDataSamples.openSampleFileStream("61300.xls"))) { DocumentEntry entry = - (DocumentEntry) poifs.getRoot().getEntry(SummaryInformation.DEFAULT_STREAM_NAME); + (DocumentEntry) poifs.getRoot().getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME); RuntimeException ex = assertThrows( RuntimeException.class, Modified: poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java Wed Sep 20 20:32:59 2023 @@ -644,7 +644,7 @@ public final class TestHSSFWorkbook exte DirectoryEntry dir = embeddedObject.getDirectory(); if (dir instanceof DirectoryNode) { DirectoryNode dNode = (DirectoryNode) dir; - if (dNode.hasEntry("WordDocument")) { + if (dNode.hasEntryCaseInsensitive("WordDocument")) { found = true; break; } Modified: poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestNonStandardWorkbookStreamNames.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestNonStandardWorkbookStreamNames.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestNonStandardWorkbookStreamNames.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestNonStandardWorkbookStreamNames.java Wed Sep 20 20:32:59 2023 @@ -121,14 +121,13 @@ final class TestNonStandardWorkbookStrea wb.close(); DirectoryNode root = wb2.getDirectory(); - // Check that we have the new entries assertTrue(root.hasEntry("Workbook")); assertFalse(root.hasEntry("BOOK")); assertFalse(root.hasEntry("WORKBOOK")); // As we preserved, should also have a few other streams - assertTrue(root.hasEntry(SummaryInformation.DEFAULT_STREAM_NAME)); + assertTrue(root.hasEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME)); wb2.close(); } } Modified: poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestPOIFSProperties.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestPOIFSProperties.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestPOIFSProperties.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/hssf/usermodel/TestPOIFSProperties.java Wed Sep 20 20:32:59 2023 @@ -89,7 +89,7 @@ class TestPOIFSProperties { summary1.setTitle(title); //write the modified property back to POIFS - fs.getRoot().getEntry(SummaryInformation.DEFAULT_STREAM_NAME).delete(); + fs.getRoot().getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME).delete(); fs.createDocument(summary1.toInputStream(), SummaryInformation.DEFAULT_STREAM_NAME); // check that the information was added successfully to the filesystem object Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/ReaderWriter.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/ReaderWriter.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/ReaderWriter.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/ReaderWriter.java Wed Sep 20 20:32:59 2023 @@ -106,7 +106,7 @@ public final class ReaderWriter implemen try { - nextEntry = entry.getEntry(componentName); + nextEntry = entry.getEntryCaseInsensitive(componentName); } catch (FileNotFoundException ignored) { Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDirectoryNode.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDirectoryNode.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDirectoryNode.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDirectoryNode.java Wed Sep 20 20:32:59 2023 @@ -73,7 +73,7 @@ final class TestDirectoryNode { assertEquals(0, node.getEntryCount()); // verify behavior of getEntry - assertThrows(FileNotFoundException.class, () -> node.getEntry("foo")); + assertThrows(FileNotFoundException.class, () -> node.getEntryCaseInsensitive("foo")); // verify behavior of isDirectoryEntry assertTrue(node.isDirectoryEntry()); @@ -124,11 +124,11 @@ final class TestDirectoryNode { assertEquals(2, node.getEntryCount()); // verify behavior of getEntry - DirectoryNode child1 = (DirectoryNode) node.getEntry("child1"); + DirectoryNode child1 = (DirectoryNode) node.getEntryCaseInsensitive("child1"); - child1.getEntry("child3"); - node.getEntry("child2"); - assertThrows(FileNotFoundException.class, () -> node.getEntry("child3")); + child1.getEntryCaseInsensitive("child3"); + node.getEntryCaseInsensitive("child2"); + assertThrows(FileNotFoundException.class, () -> node.getEntryCaseInsensitive("child3")); // verify behavior of isDirectoryEntry assertTrue(node.isDirectoryEntry()); Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocument.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocument.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocument.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocument.java Wed Sep 20 20:32:59 2023 @@ -101,8 +101,8 @@ class TestDocument { POIFSFileSystem poifs = document.getFileSystem(); String name = "test" + input.length; DirectoryNode root = poifs.getRoot(); - if (root.hasEntry(name)) { - root.deleteEntry((EntryNode)root.getEntry(name)); + if (root.hasEntryCaseInsensitive(name)) { + root.deleteEntry((EntryNode)root.getEntryCaseInsensitive(name)); } return ((DocumentNode)root .createDocument(name, new ByteArrayInputStream(input))) Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestDocumentInputStream.java Wed Sep 20 20:32:59 2023 @@ -381,22 +381,22 @@ final class TestDocumentInputStream { // Check inside DirectoryNode root = poifs.getRoot(); // Top Level - Entry top = root.getEntry("Contents"); + Entry top = root.getEntryCaseInsensitive("Contents"); assertTrue(top.isDocumentEntry()); stream = root.createDocumentInputStream(top); assertNotEquals(-1, stream.read()); // One Level Down - DirectoryNode escher = (DirectoryNode) root.getEntry("Escher"); - Entry one = escher.getEntry("EscherStm"); + DirectoryNode escher = (DirectoryNode) root.getEntryCaseInsensitive("Escher"); + Entry one = escher.getEntryCaseInsensitive("EscherStm"); assertTrue(one.isDocumentEntry()); stream = escher.createDocumentInputStream(one); assertNotEquals(-1, stream.read()); // Two Levels Down - DirectoryNode quill = (DirectoryNode) root.getEntry("Quill"); - DirectoryNode quillSub = (DirectoryNode) quill.getEntry("QuillSub"); - Entry two = quillSub.getEntry("CONTENTS"); + DirectoryNode quill = (DirectoryNode) root.getEntryCaseInsensitive("Quill"); + DirectoryNode quillSub = (DirectoryNode) quill.getEntryCaseInsensitive("QuillSub"); + Entry two = quillSub.getEntryCaseInsensitive("CONTENTS"); assertTrue(two.isDocumentEntry()); stream = quillSub.createDocumentInputStream(two); assertNotEquals(-1, stream.read()); Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEmptyDocument.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEmptyDocument.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEmptyDocument.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEmptyDocument.java Wed Sep 20 20:32:59 2023 @@ -101,13 +101,13 @@ final class TestEmptyDocument { // This line caused the error. try (POIFSFileSystem fs = new POIFSFileSystem(out.toInputStream())) { - DocumentEntry entry = (DocumentEntry) fs.getRoot().getEntry("Empty"); + DocumentEntry entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Empty"); assertEquals(0, entry.getSize(), "Expected zero size"); byte[] actualReadbackData; actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry)); assertEquals(0, actualReadbackData.length, "Expected zero read from stream"); - entry = (DocumentEntry) fs.getRoot().getEntry("NotEmpty"); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("NotEmpty"); actualReadbackData = IOUtils.toByteArray(new DocumentInputStream(entry)); assertEquals(testData.length, entry.getSize(), "Expected size was wrong"); assertArrayEquals(testData, actualReadbackData, "Expected same data read from stream"); Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEntryUtils.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEntryUtils.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEntryUtils.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestEntryUtils.java Wed Sep 20 20:32:59 2023 @@ -53,18 +53,18 @@ class TestEntryUtils { EntryUtils.copyNodeRecursively(entryR, fsD.getRoot()); assertEquals(1, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("EntryRoot")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryRoot")); EntryUtils.copyNodeRecursively(entryA1, fsD.getRoot()); assertEquals(2, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("EntryRoot")); - assertNotNull(fsD.getRoot().getEntry("EntryA1")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryRoot")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryA1")); EntryUtils.copyNodeRecursively(entryA2, fsD.getRoot()); assertEquals(3, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("EntryRoot")); - assertNotNull(fsD.getRoot().getEntry("EntryA1")); - assertNotNull(fsD.getRoot().getEntry("EntryA2")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryRoot")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryA1")); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("EntryA2")); fsD.close(); @@ -74,15 +74,15 @@ class TestEntryUtils { EntryUtils.copyNodeRecursively(dirB, fsD.getRoot()); assertEquals(1, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("DirB")); - assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntry("DirB")).getEntryCount()); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("DirB")); + assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntryCaseInsensitive("DirB")).getEntryCount()); EntryUtils.copyNodeRecursively(dirA, fsD.getRoot()); assertEquals(2, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("DirB")); - assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntry("DirB")).getEntryCount()); - assertNotNull(fsD.getRoot().getEntry("DirA")); - assertEquals(2, ((DirectoryEntry)fsD.getRoot().getEntry("DirA")).getEntryCount()); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("DirB")); + assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntryCaseInsensitive("DirB")).getEntryCount()); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive("DirA")); + assertEquals(2, ((DirectoryEntry)fsD.getRoot().getEntryCaseInsensitive("DirA")).getEntryCount()); fsD.close(); // Copy the whole lot @@ -91,11 +91,11 @@ class TestEntryUtils { EntryUtils.copyNodes(fs, fsD, new ArrayList<>()); assertEquals(3, fsD.getRoot().getEntryCount()); - assertNotNull(fsD.getRoot().getEntry(dirA.getName())); - assertNotNull(fsD.getRoot().getEntry(dirB.getName())); - assertNotNull(fsD.getRoot().getEntry(entryR.getName())); - assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntry("DirB")).getEntryCount()); - assertEquals(2, ((DirectoryEntry)fsD.getRoot().getEntry("DirA")).getEntryCount()); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive(dirA.getName())); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive(dirB.getName())); + assertNotNull(fsD.getRoot().getEntryCaseInsensitive(entryR.getName())); + assertEquals(0, ((DirectoryEntry)fsD.getRoot().getEntryCaseInsensitive("DirB")).getEntryCount()); + assertEquals(2, ((DirectoryEntry)fsD.getRoot().getEntryCaseInsensitive("DirA")).getEntryCount()); fsD.close(); fs.close(); } @@ -131,11 +131,11 @@ class TestEntryUtils { try (InputStream tmpI = tmpO.toInputStream(); POIFSFileSystem nfs = new POIFSFileSystem(tmpI)) { - DirectoryEntry dN1 = (DirectoryEntry) nfs.getRoot().getEntry("DirA"); - DirectoryEntry dN2 = (DirectoryEntry) nfs.getRoot().getEntry("DirB"); - DocumentEntry eNA1 = (DocumentEntry) dN1.getEntry(entryA1.getName()); - DocumentEntry eNA2 = (DocumentEntry) dN1.getEntry(entryA2.getName()); - DocumentEntry eNB1 = (DocumentEntry) dN2.getEntry(entryB1.getName()); + DirectoryEntry dN1 = (DirectoryEntry) nfs.getRoot().getEntryCaseInsensitive("DirA"); + DirectoryEntry dN2 = (DirectoryEntry) nfs.getRoot().getEntryCaseInsensitive("DirB"); + DocumentEntry eNA1 = (DocumentEntry) dN1.getEntryCaseInsensitive(entryA1.getName()); + DocumentEntry eNA2 = (DocumentEntry) dN1.getEntryCaseInsensitive(entryA2.getName()); + DocumentEntry eNB1 = (DocumentEntry) dN2.getEntryCaseInsensitive(entryB1.getName()); assertFalse(EntryUtils.areDocumentsIdentical(eNA1, eNA2)); assertTrue(EntryUtils.areDocumentsIdentical(eNA1, eNB1)); Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestFilteringDirectoryNode.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestFilteringDirectoryNode.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestFilteringDirectoryNode.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestFilteringDirectoryNode.java Wed Sep 20 20:32:59 2023 @@ -63,16 +63,16 @@ final class TestFilteringDirectoryNode { void testNoFiltering() throws Exception { FilteringDirectoryNode d = new FilteringDirectoryNode(fs.getRoot(), new HashSet<>()); assertEquals(3, d.getEntryCount()); - assertEquals(dirA.getName(), d.getEntry(dirA.getName()).getName()); + assertEquals(dirA.getName(), d.getEntryCaseInsensitive(dirA.getName()).getName()); - assertTrue(d.getEntry(dirA.getName()).isDirectoryEntry()); - assertFalse(d.getEntry(dirA.getName()).isDocumentEntry()); + assertTrue(d.getEntryCaseInsensitive(dirA.getName()).isDirectoryEntry()); + assertFalse(d.getEntryCaseInsensitive(dirA.getName()).isDocumentEntry()); - assertTrue(d.getEntry(dirB.getName()).isDirectoryEntry()); - assertFalse(d.getEntry(dirB.getName()).isDocumentEntry()); + assertTrue(d.getEntryCaseInsensitive(dirB.getName()).isDirectoryEntry()); + assertFalse(d.getEntryCaseInsensitive(dirB.getName()).isDocumentEntry()); - assertFalse(d.getEntry(eRoot.getName()).isDirectoryEntry()); - assertTrue(d.getEntry(eRoot.getName()).isDocumentEntry()); + assertFalse(d.getEntryCaseInsensitive(eRoot.getName()).isDirectoryEntry()); + assertTrue(d.getEntryCaseInsensitive(eRoot.getName()).isDocumentEntry()); Iterator<Entry> i = d.getEntries(); assertEquals(dirA, i.next()); @@ -93,13 +93,13 @@ final class TestFilteringDirectoryNode { FilteringDirectoryNode d1 = new FilteringDirectoryNode(fs.getRoot(), excl); assertEquals(2, d1.getEntryCount()); - assertTrue(d1.hasEntry(dirA.getName())); - assertTrue(d1.hasEntry(dirB.getName())); - assertFalse(d1.hasEntry(eRoot.getName())); - - assertEquals(dirA, d1.getEntry(dirA.getName())); - assertEquals(dirB, d1.getEntry(dirB.getName())); - assertThrows(FileNotFoundException.class, () -> d1.getEntry(eRoot.getName())); + assertTrue(d1.hasEntryCaseInsensitive(dirA.getName())); + assertTrue(d1.hasEntryCaseInsensitive(dirB.getName())); + assertFalse(d1.hasEntryCaseInsensitive(eRoot.getName())); + + assertEquals(dirA, d1.getEntryCaseInsensitive(dirA.getName())); + assertEquals(dirB, d1.getEntryCaseInsensitive(dirB.getName())); + assertThrows(FileNotFoundException.class, () -> d1.getEntryCaseInsensitive(eRoot.getName())); Iterator<Entry> i = d1.getEntries(); assertEquals(dirA, i.next()); @@ -117,12 +117,12 @@ final class TestFilteringDirectoryNode { FilteringDirectoryNode d2 = new FilteringDirectoryNode(fs.getRoot(), excl); assertEquals(1, d2.getEntryCount()); - assertFalse(d2.hasEntry(dirA.getName())); - assertTrue(d2.hasEntry(dirB.getName())); - assertFalse(d2.hasEntry(eRoot.getName())); - assertThrows(FileNotFoundException.class, () -> d2.getEntry(dirA.getName()), "Should be filtered"); - assertEquals(dirB, d2.getEntry(dirB.getName())); - assertThrows(FileNotFoundException.class, () -> d2.getEntry(eRoot.getName()), "Should be filtered"); + assertFalse(d2.hasEntryCaseInsensitive(dirA.getName())); + assertTrue(d2.hasEntryCaseInsensitive(dirB.getName())); + assertFalse(d2.hasEntryCaseInsensitive(eRoot.getName())); + assertThrows(FileNotFoundException.class, () -> d2.getEntryCaseInsensitive(dirA.getName()), "Should be filtered"); + assertEquals(dirB, d2.getEntryCaseInsensitive(dirB.getName())); + assertThrows(FileNotFoundException.class, () -> d2.getEntryCaseInsensitive(eRoot.getName()), "Should be filtered"); i = d2.getEntries(); assertEquals(dirB, i.next()); @@ -137,12 +137,12 @@ final class TestFilteringDirectoryNode { FilteringDirectoryNode d3 = new FilteringDirectoryNode(fs.getRoot(), excl); assertEquals(0, d3.getEntryCount()); - assertFalse(d3.hasEntry(dirA.getName())); - assertFalse(d3.hasEntry(dirB.getName())); - assertFalse(d3.hasEntry(eRoot.getName())); - assertThrows(FileNotFoundException.class, () -> d3.getEntry(dirA.getName()), "Should be filtered"); - assertThrows(FileNotFoundException.class, () -> d3.getEntry(dirB.getName()), "Should be filtered"); - assertThrows(FileNotFoundException.class, () -> d3.getEntry(eRoot.getName()), "Should be filtered"); + assertFalse(d3.hasEntryCaseInsensitive(dirA.getName())); + assertFalse(d3.hasEntryCaseInsensitive(dirB.getName())); + assertFalse(d3.hasEntryCaseInsensitive(eRoot.getName())); + assertThrows(FileNotFoundException.class, () -> d3.getEntryCaseInsensitive(dirA.getName()), "Should be filtered"); + assertThrows(FileNotFoundException.class, () -> d3.getEntryCaseInsensitive(dirB.getName()), "Should be filtered"); + assertThrows(FileNotFoundException.class, () -> d3.getEntryCaseInsensitive(eRoot.getName()), "Should be filtered"); i = d3.getEntries(); assertThrows(NoSuchElementException.class, i::next, "Should throw NoSuchElementException when depleted"); @@ -161,24 +161,24 @@ final class TestFilteringDirectoryNode { // Check main assertEquals(2, d.getEntryCount()); - assertTrue(d.hasEntry(dirA.getName())); - assertTrue(d.hasEntry(dirB.getName())); - assertFalse(d.hasEntry(eRoot.getName())); + assertTrue(d.hasEntryCaseInsensitive(dirA.getName())); + assertTrue(d.hasEntryCaseInsensitive(dirB.getName())); + assertFalse(d.hasEntryCaseInsensitive(eRoot.getName())); // Check filtering down - assertTrue(d.getEntry(dirA.getName()) instanceof FilteringDirectoryNode); - assertFalse(d.getEntry(dirB.getName()) instanceof FilteringDirectoryNode); + assertTrue(d.getEntryCaseInsensitive(dirA.getName()) instanceof FilteringDirectoryNode); + assertFalse(d.getEntryCaseInsensitive(dirB.getName()) instanceof FilteringDirectoryNode); - DirectoryEntry fdA = (DirectoryEntry) d.getEntry(dirA.getName()); - assertFalse(fdA.hasEntry(eA.getName())); - assertTrue(fdA.hasEntry(dirAA.getName())); + DirectoryEntry fdA = (DirectoryEntry) d.getEntryCaseInsensitive(dirA.getName()); + assertFalse(fdA.hasEntryCaseInsensitive(eA.getName())); + assertTrue(fdA.hasEntryCaseInsensitive(dirAA.getName())); - DirectoryEntry fdAA = (DirectoryEntry) fdA.getEntry(dirAA.getName()); - assertTrue(fdAA.hasEntry(eAA.getName())); + DirectoryEntry fdAA = (DirectoryEntry) fdA.getEntryCaseInsensitive(dirAA.getName()); + assertTrue(fdAA.hasEntryCaseInsensitive(eAA.getName())); } @Test void testNullDirectory() { assertThrows(IllegalArgumentException.class, () -> new FilteringDirectoryNode(null, null)); } -} \ No newline at end of file +} Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSFileSystem.java Wed Sep 20 20:32:59 2023 @@ -214,7 +214,7 @@ final class TestPOIFSFileSystem { DirectoryNode root = fs.getRoot(); assertEquals(1, root.getEntryCount()); - DocumentNode big = (DocumentNode)root.getEntry("BIG"); + DocumentNode big = (DocumentNode)root.getEntryCaseInsensitive("BIG"); assertEquals(hugeStream.length, big.getSize()); } Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSMiniStore.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSMiniStore.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSMiniStore.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSMiniStore.java Wed Sep 20 20:32:59 2023 @@ -390,7 +390,7 @@ final class TestPOIFSMiniStore { assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(2)); // Check the data is unchanged and the right length - entry = (DocumentEntry) fs.getRoot().getEntry("mini"); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("mini"); assertEquals(data.length, entry.getSize()); byte[] rdata = new byte[data.length]; dis = new DocumentInputStream(entry); @@ -398,7 +398,7 @@ final class TestPOIFSMiniStore { assertArrayEquals(data, rdata); dis.close(); - entry = (DocumentEntry) fs.getRoot().getEntry("mini2"); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("mini2"); assertEquals(data.length, entry.getSize()); rdata = new byte[data.length]; dis = new DocumentInputStream(entry); Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSStream.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSStream.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSStream.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPOIFSStream.java Wed Sep 20 20:32:59 2023 @@ -960,7 +960,7 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.END_OF_CHAIN, bat.getValueAt(10)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(11)); - DocumentEntry normal = (DocumentEntry) fs1.getRoot().getEntry("Normal"); + DocumentEntry normal = (DocumentEntry) fs1.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4106, normal.getSize()); assertEquals(4106, ((DocumentNode) normal).getProperty().getSize()); @@ -988,7 +988,7 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(10)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(11)); - normal = (DocumentEntry) fs1.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs1.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4096, normal.getSize()); assertEquals(4096, ((DocumentNode) normal).getProperty().getSize()); @@ -1011,13 +1011,13 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(10)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(11)); - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4096, normal.getSize()); assertEquals(4096, ((DocumentNode) normal).getProperty().getSize()); // Make longer, take 1 block at the end - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); try (DocumentOutputStream nout = new DocumentOutputStream(normal)) { nout.write(main4106); } @@ -1036,14 +1036,14 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(11)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(12)); - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4106, normal.getSize()); assertEquals(4106, ((DocumentNode) normal).getProperty().getSize()); // Make it small, will trigger the SBAT stream and free lots up byte[] mini = new byte[]{42, 0, 1, 2, 3, 4, 42}; - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); try (DocumentOutputStream nout = new DocumentOutputStream(normal)) { nout.write(mini); } @@ -1062,7 +1062,7 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(11)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(12)); - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(7, normal.getSize()); assertEquals(7, ((DocumentNode) normal).getProperty().getSize()); @@ -1088,7 +1088,7 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(12)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(13)); - normal = (DocumentEntry) fs2.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs2.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4096, normal.getSize()); assertEquals(4096, ((DocumentNode) normal).getProperty().getSize()); @@ -1112,7 +1112,7 @@ final class TestPOIFSStream { assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(12)); assertEquals(POIFSConstants.UNUSED_BLOCK, bat.getValueAt(13)); - normal = (DocumentEntry) fs3.getRoot().getEntry("Normal"); + normal = (DocumentEntry) fs3.getRoot().getEntryCaseInsensitive("Normal"); assertEquals(4096, normal.getSize()); assertEquals(4096, ((DocumentNode) normal).getProperty().getSize()); } @@ -1639,11 +1639,11 @@ final class TestPOIFSStream { assertEquals(5, root.getEntryCount()); // Check by the names - Entry thumbnail = root.getEntry("Thumbnail"); - Entry dsi = root.getEntry("\u0005DocumentSummaryInformation"); - Entry si = root.getEntry("\u0005SummaryInformation"); - Entry image = root.getEntry("Image"); - Entry tags = root.getEntry("Tags"); + Entry thumbnail = root.getEntryCaseInsensitive("Thumbnail"); + Entry dsi = root.getEntryCaseInsensitive("\u0005DocumentSummaryInformation"); + Entry si = root.getEntryCaseInsensitive("\u0005SummaryInformation"); + Entry image = root.getEntryCaseInsensitive("Image"); + Entry tags = root.getEntryCaseInsensitive("Tags"); assertFalse(thumbnail.isDirectoryEntry()); assertFalse(dsi.isDirectoryEntry()); @@ -1675,7 +1675,7 @@ final class TestPOIFSStream { throws IOException, NoPropertySetStreamException { try (POIFSFileSystem fs = opener.apply(file)) { DirectoryEntry root = fs.getRoot(); - Entry si = root.getEntry("\u0005SummaryInformation"); + Entry si = root.getEntryCaseInsensitive("\u0005SummaryInformation"); assertTrue(si.isDocumentEntry()); DocumentNode doc = (DocumentNode) si; @@ -1697,7 +1697,7 @@ final class TestPOIFSStream { // Try the other summary information - si = root.getEntry("\u0005DocumentSummaryInformation"); + si = root.getEntryCaseInsensitive("\u0005DocumentSummaryInformation"); assertTrue(si.isDocumentEntry()); doc = (DocumentNode) si; assertContentsMatches(null, doc); @@ -1745,11 +1745,11 @@ final class TestPOIFSStream { // Check the contents of them - parse the summary block and check sinf = (SummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, sinf.getOSVersion()); dinf = (DocumentSummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, dinf.getOSVersion()); @@ -1765,7 +1765,7 @@ final class TestPOIFSStream { try (POIFSFileSystem fs3 = writeOutAndReadBack(fs2)) { root = fs3.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(6, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); assertThat(root.getEntryNames(), hasItem("Image")); @@ -1777,21 +1777,21 @@ final class TestPOIFSStream { // Check old and new are there sinf = (SummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, sinf.getOSVersion()); dinf = (DocumentSummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, dinf.getOSVersion()); - assertContentsMatches(mini, (DocumentEntry) testDir.getEntry("Mini")); + assertContentsMatches(mini, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini")); // Write out and read once more, just to be sure try (POIFSFileSystem fs4 = writeOutAndReadBack(fs3)) { root = fs4.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(6, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); assertThat(root.getEntryNames(), hasItem("Image")); @@ -1801,14 +1801,14 @@ final class TestPOIFSStream { assertThat(root.getEntryNames(), hasItem("\u0005SummaryInformation")); sinf = (SummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, sinf.getOSVersion()); dinf = (DocumentSummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, dinf.getOSVersion()); - assertContentsMatches(mini, (DocumentEntry) testDir.getEntry("Mini")); + assertContentsMatches(mini, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini")); // Add a full stream, delete a full stream @@ -1817,7 +1817,7 @@ final class TestPOIFSStream { main4096[4095] = -11; testDir.createDocument("Normal4096", new ByteArrayInputStream(main4096)); - root.getEntry("Tags").delete(); + root.getEntryCaseInsensitive("Tags").delete(); // Write out, re-load @@ -1825,7 +1825,7 @@ final class TestPOIFSStream { // Check it's all there root = fs5.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(5, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); assertThat(root.getEntryNames(), hasItem("Image")); @@ -1836,19 +1836,19 @@ final class TestPOIFSStream { // Check old and new are there sinf = (SummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(SummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(SummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, sinf.getOSVersion()); dinf = (DocumentSummaryInformation) PropertySetFactory.create(new DocumentInputStream( - (DocumentEntry) root.getEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); + (DocumentEntry) root.getEntryCaseInsensitive(DocumentSummaryInformation.DEFAULT_STREAM_NAME))); assertEquals(131333, dinf.getOSVersion()); - assertContentsMatches(mini, (DocumentEntry) testDir.getEntry("Mini")); - assertContentsMatches(main4096, (DocumentEntry) testDir.getEntry("Normal4096")); + assertContentsMatches(mini, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini")); + assertContentsMatches(main4096, (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096")); // Delete a directory, and add one more - testDir.getEntry("Testing 456").delete(); + testDir.getEntryCaseInsensitive("Testing 456").delete(); testDir.createDirectory("Testing ABC"); @@ -1857,7 +1857,7 @@ final class TestPOIFSStream { // Check root = fs6.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(5, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); @@ -1881,7 +1881,7 @@ final class TestPOIFSStream { try (POIFSFileSystem fs7 = writeOutAndReadBack(fs6)) { root = fs7.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(5, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); @@ -1897,13 +1897,13 @@ final class TestPOIFSStream { assertThat(testDir.getEntryNames(), hasItem("Testing 789")); assertThat(testDir.getEntryNames(), hasItem("Testing ABC")); - assertContentsMatches(mini, (DocumentEntry) testDir.getEntry("Mini")); - assertContentsMatches(mini2, (DocumentEntry) testDir.getEntry("Mini2")); - assertContentsMatches(main4096, (DocumentEntry) testDir.getEntry("Normal4096")); + assertContentsMatches(mini, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini")); + assertContentsMatches(mini2, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2")); + assertContentsMatches(main4096, (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096")); // Delete a mini stream, add one more - testDir.getEntry("Mini").delete(); + testDir.getEntryCaseInsensitive("Mini").delete(); byte[] mini3 = new byte[]{42, 0, 42, 0, 42, 0, 42}; testDir.createDocument("Mini3", new ByteArrayInputStream(mini3)); @@ -1913,7 +1913,7 @@ final class TestPOIFSStream { try (POIFSFileSystem fs8 = writeOutAndReadBack(fs7)) { root = fs8.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(5, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); @@ -1929,19 +1929,19 @@ final class TestPOIFSStream { assertThat(testDir.getEntryNames(), hasItem("Testing 789")); assertThat(testDir.getEntryNames(), hasItem("Testing ABC")); - assertContentsMatches(mini2, (DocumentEntry) testDir.getEntry("Mini2")); - assertContentsMatches(mini3, (DocumentEntry) testDir.getEntry("Mini3")); - assertContentsMatches(main4096, (DocumentEntry) testDir.getEntry("Normal4096")); + assertContentsMatches(mini2, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2")); + assertContentsMatches(mini3, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini3")); + assertContentsMatches(main4096, (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096")); // Change some existing streams - POIFSDocument mini2Doc = new POIFSDocument((DocumentNode) testDir.getEntry("Mini2")); + POIFSDocument mini2Doc = new POIFSDocument((DocumentNode) testDir.getEntryCaseInsensitive("Mini2")); mini2Doc.replaceContents(new ByteArrayInputStream(mini)); byte[] main4106 = new byte[4106]; main4106[0] = 41; main4106[4105] = 42; - POIFSDocument mainDoc = new POIFSDocument((DocumentNode) testDir.getEntry("Normal4096")); + POIFSDocument mainDoc = new POIFSDocument((DocumentNode) testDir.getEntryCaseInsensitive("Normal4096")); mainDoc.replaceContents(new ByteArrayInputStream(main4106)); @@ -1949,7 +1949,7 @@ final class TestPOIFSStream { try (POIFSFileSystem fs9 = writeOutAndReadBack(fs8)) { root = fs9.getRoot(); - testDir = (DirectoryEntry) root.getEntry("Testing 123"); + testDir = (DirectoryEntry) root.getEntryCaseInsensitive("Testing 123"); assertEquals(5, root.getEntryCount()); assertThat(root.getEntryNames(), hasItem("Thumbnail")); @@ -1965,9 +1965,9 @@ final class TestPOIFSStream { assertThat(testDir.getEntryNames(), hasItem("Testing 789")); assertThat(testDir.getEntryNames(), hasItem("Testing ABC")); - assertContentsMatches(mini, (DocumentEntry) testDir.getEntry("Mini2")); - assertContentsMatches(mini3, (DocumentEntry) testDir.getEntry("Mini3")); - assertContentsMatches(main4106, (DocumentEntry) testDir.getEntry("Normal4096")); + assertContentsMatches(mini, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2")); + assertContentsMatches(mini3, (DocumentEntry) testDir.getEntryCaseInsensitive("Mini3")); + assertContentsMatches(main4106, (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096")); } } } @@ -2165,16 +2165,16 @@ final class TestPOIFSStream { // Check some data assertEquals(1, fs5.getRoot().getEntryCount()); - testDir = (DirectoryEntry) fs5.getRoot().getEntry("Test Directory"); + testDir = (DirectoryEntry) fs5.getRoot().getEntryCaseInsensitive("Test Directory"); assertEquals(3, testDir.getEntryCount()); - DocumentEntry miniDoc = (DocumentEntry) testDir.getEntry("Mini"); + DocumentEntry miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini"); assertContentsMatches(mini, miniDoc); - DocumentEntry normDoc = (DocumentEntry) testDir.getEntry("Normal4096"); + DocumentEntry normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096"); assertContentsMatches(main4096, normDoc); - normDoc = (DocumentEntry) testDir.getEntry("Normal5124"); + normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal5124"); assertContentsMatches(main5124, normDoc); @@ -2278,10 +2278,10 @@ final class TestPOIFSStream { // Check that we can read the right data pre-write - DocumentEntry miniDoc = (DocumentEntry) testDir.getEntry("Mini"); + DocumentEntry miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini"); assertContentsMatches(mini, miniDoc); - DocumentEntry normDoc = (DocumentEntry) testDir.getEntry("Normal4096"); + DocumentEntry normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096"); assertContentsMatches(main4096, normDoc); @@ -2319,16 +2319,16 @@ final class TestPOIFSStream { DirectoryEntry fsRoot = fs2.getRoot(); assertEquals(1, fsRoot.getEntryCount()); - parentDir = (DirectoryEntry) fsRoot.getEntry("Parent Directory"); + parentDir = (DirectoryEntry) fsRoot.getEntryCaseInsensitive("Parent Directory"); assertEquals(1, parentDir.getEntryCount()); - testDir = (DirectoryEntry) parentDir.getEntry("Test Directory"); + testDir = (DirectoryEntry) parentDir.getEntryCaseInsensitive("Test Directory"); assertEquals(2, testDir.getEntryCount()); - miniDoc = (DocumentEntry) testDir.getEntry("Mini"); + miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini"); assertContentsMatches(mini, miniDoc); - normDoc = (DocumentEntry) testDir.getEntry("Normal4096"); + normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4096"); assertContentsMatches(main4096, normDoc); @@ -2347,19 +2347,19 @@ final class TestPOIFSStream { fsRoot = fs3.getRoot(); assertEquals(1, fsRoot.getEntryCount()); - parentDir = (DirectoryEntry) fsRoot.getEntry("Parent Directory"); + parentDir = (DirectoryEntry) fsRoot.getEntryCaseInsensitive("Parent Directory"); assertEquals(1, parentDir.getEntryCount()); - testDir = (DirectoryEntry) parentDir.getEntry("Test Directory"); + testDir = (DirectoryEntry) parentDir.getEntryCaseInsensitive("Test Directory"); assertEquals(4, testDir.getEntryCount()); - miniDoc = (DocumentEntry) testDir.getEntry("Mini"); + miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini"); assertContentsMatches(mini, miniDoc); - miniDoc = (DocumentEntry) testDir.getEntry("Mini2"); + miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2"); assertContentsMatches(mini2, miniDoc); - normDoc = (DocumentEntry) testDir.getEntry("Normal4106"); + normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4106"); assertContentsMatches(main4106, normDoc); } } @@ -2372,15 +2372,15 @@ final class TestPOIFSStream { DirectoryNode testDir = fs.getRoot(); assertEquals(3, testDir.getEntryCount()); - DocumentEntry entry = (DocumentEntry) testDir.getEntry("test-zero-1"); + DocumentEntry entry = (DocumentEntry) testDir.getEntryCaseInsensitive("test-zero-1"); assertNotNull(entry); assertEquals(0, entry.getSize()); - entry = (DocumentEntry) testDir.getEntry("test-zero-2"); + entry = (DocumentEntry) testDir.getEntryCaseInsensitive("test-zero-2"); assertNotNull(entry); assertEquals(0, entry.getSize()); - entry = (DocumentEntry) testDir.getEntry("test-zero-3"); + entry = (DocumentEntry) testDir.getEntryCaseInsensitive("test-zero-3"); assertNotNull(entry); assertEquals(0, entry.getSize()); @@ -2419,19 +2419,19 @@ final class TestPOIFSStream { testDir.createDocument("empty-3", new ByteArrayInputStream(empty)); // Check - miniDoc = (DocumentEntry) testDir.getEntry("Mini2"); + miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2"); assertContentsMatches(mini2, miniDoc); - normDoc = (DocumentEntry) testDir.getEntry("Normal4106"); + normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4106"); assertContentsMatches(main4106, normDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-1"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-1"); assertContentsMatches(empty, emptyDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-2"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-2"); assertContentsMatches(empty, emptyDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-3"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-3"); assertContentsMatches(empty, emptyDoc); // Look at the properties entry, and check the empty ones @@ -2469,19 +2469,19 @@ final class TestPOIFSStream { try (POIFSFileSystem fs2 = writeOutAndReadBack(fs1)) { testDir = fs2.getRoot(); - miniDoc = (DocumentEntry) testDir.getEntry("Mini2"); + miniDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Mini2"); assertContentsMatches(mini2, miniDoc); - normDoc = (DocumentEntry) testDir.getEntry("Normal4106"); + normDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("Normal4106"); assertContentsMatches(main4106, normDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-1"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-1"); assertContentsMatches(empty, emptyDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-2"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-2"); assertContentsMatches(empty, emptyDoc); - emptyDoc = (DocumentEntry) testDir.getEntry("empty-3"); + emptyDoc = (DocumentEntry) testDir.getEntryCaseInsensitive("empty-3"); assertContentsMatches(empty, emptyDoc); // Check that a mini-stream was assigned, with one block used @@ -2528,7 +2528,7 @@ final class TestPOIFSStream { assertEquals(5, src.getRoot().getEntryCount()); // Grab the VBA project root - DirectoryEntry vbaProj = (DirectoryEntry) src.getRoot().getEntry("_VBA_PROJECT_CUR"); + DirectoryEntry vbaProj = (DirectoryEntry) src.getRoot().getEntryCaseInsensitive("_VBA_PROJECT_CUR"); assertEquals(3, vbaProj.getEntryCount()); // Can't delete yet, has stuff assertFalse(vbaProj.delete()); @@ -2550,7 +2550,7 @@ final class TestPOIFSStream { DirectoryEntry dir = (DirectoryEntry) entry; String[] names = dir.getEntryNames().toArray(new String[dir.getEntryCount()]); for (String name : names) { - Entry ce = dir.getEntry(name); + Entry ce = dir.getEntryCaseInsensitive(name); _recursiveDeletee(ce); } assertTrue(dir.delete()); @@ -2602,7 +2602,7 @@ final class TestPOIFSStream { // Extend it past the 2gb mark try (POIFSFileSystem fs = new POIFSFileSystem(big, false)) { for (int i = 0; i < 19; i++) { - entry = (DocumentEntry) fs.getRoot().getEntry("Entry" + i); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Entry" + i); assertNotNull(entry); assertEquals(s100mb, entry.getSize()); } @@ -2614,11 +2614,11 @@ final class TestPOIFSStream { // Check it still works try (POIFSFileSystem fs = new POIFSFileSystem(big, false)) { for (int i = 0; i < 19; i++) { - entry = (DocumentEntry) fs.getRoot().getEntry("Entry" + i); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Entry" + i); assertNotNull(entry); assertEquals(s100mb, entry.getSize()); } - entry = (DocumentEntry) fs.getRoot().getEntry("Bigger"); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Bigger"); assertNotNull(entry); assertEquals(s512mb, entry.getSize()); } @@ -2637,7 +2637,7 @@ final class TestPOIFSStream { // Read it try (POIFSFileSystem fs = new POIFSFileSystem(big, false)) { for (int i = 0; i < 4; i++) { - entry = (DocumentEntry) fs.getRoot().getEntry("Entry" + i); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Entry" + i); assertNotNull(entry); assertEquals(s512mb, entry.getSize()); } @@ -2650,7 +2650,7 @@ final class TestPOIFSStream { // Check it worked try (POIFSFileSystem fs = new POIFSFileSystem(big, false)) { for (int i = 0; i < 5; i++) { - entry = (DocumentEntry) fs.getRoot().getEntry("Entry" + i); + entry = (DocumentEntry) fs.getRoot().getEntryCaseInsensitive("Entry" + i); assertNotNull(entry); assertEquals(s512mb, entry.getSize()); } Modified: poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPropertySorter.java URL: http://svn.apache.org/viewvc/poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPropertySorter.java?rev=1912438&r1=1912437&r2=1912438&view=diff ============================================================================== --- poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPropertySorter.java (original) +++ poi/trunk/poi/src/test/java/org/apache/poi/poifs/filesystem/TestPropertySorter.java Wed Sep 20 20:32:59 2023 @@ -116,9 +116,9 @@ final class TestPropertySorter { String VBA = "VBA"; DirectoryEntry root = fs.getRoot(); - DirectoryEntry vba_project = (DirectoryEntry)root.getEntry(_VBA_PROJECT_CUR); + DirectoryEntry vba_project = (DirectoryEntry)root.getEntryCaseInsensitive(_VBA_PROJECT_CUR); - DirectoryNode vba = (DirectoryNode)vba_project.getEntry(VBA); + DirectoryNode vba = (DirectoryNode)vba_project.getEntryCaseInsensitive(VBA); DirectoryProperty p = (DirectoryProperty)vba.getProperty(); List<Property> lst = new ArrayList<>(); Added: poi/trunk/test-data/document/47950_lower.doc URL: http://svn.apache.org/viewvc/poi/trunk/test-data/document/47950_lower.doc?rev=1912438&view=auto ============================================================================== Binary files poi/trunk/test-data/document/47950_lower.doc (added) and poi/trunk/test-data/document/47950_lower.doc Wed Sep 20 20:32:59 2023 differ Added: poi/trunk/test-data/document/47950_normal.doc URL: http://svn.apache.org/viewvc/poi/trunk/test-data/document/47950_normal.doc?rev=1912438&view=auto ============================================================================== Binary files poi/trunk/test-data/document/47950_normal.doc (added) and poi/trunk/test-data/document/47950_normal.doc Wed Sep 20 20:32:59 2023 differ Added: poi/trunk/test-data/document/47950_upper.doc URL: http://svn.apache.org/viewvc/poi/trunk/test-data/document/47950_upper.doc?rev=1912438&view=auto ============================================================================== Binary files poi/trunk/test-data/document/47950_upper.doc (added) and poi/trunk/test-data/document/47950_upper.doc Wed Sep 20 20:32:59 2023 differ --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
