Example #1
0
        public void HandlesEscapedEscapeCharacters()
        {
            const string s = @"(   \(sleep 1; printf ""QUIT\\r\\n""\) | )";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(@"   (sleep 1; printf ""QUIT\r\n"") | ", AssertStringToken(token).Data);
        }
Example #2
0
        public void ConvertsPartialOctal()
        {
            const string s = @"(This string has a plus: \53 as octal)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("This string has a plus: + as octal", AssertStringToken(token).Data);
        }
Example #3
0
        public void ReadsNameAtEndOfStream()
        {
            const string s = "/XRef";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("XRef", AssertNameToken(token).Data);
        }
Example #4
0
        public void CanHandleNestedParentheses()
        {
            const string s = "(this string (contains nested (two levels)) parentheses)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("this string (contains nested (two levels)) parentheses", AssertStringToken(token).Data);
        }
Example #5
0
        public void ReadsHeaderWithBlankSpaceBefore()
        {
            const string input = @"     

%PDF-1.2";

            var scanner = StringBytesTestConverter.Scanner(input);

            var result = FileHeaderParser.Parse(scanner, false, log);

            Assert.Equal(1.2m, result.Version);
        }
Example #6
0
        public void CanHandleEscapedParentheses()
        {
            const string s = "(this string \\)contains escaped \\( parentheses)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(@"this string )contains escaped ( parentheses", AssertStringToken(token).Data);
        }
Example #7
0
        public void ConvertsFullOctalFollowedByNormalNumber()
        {
            const string s = @"(This string contains \2451 octal character.)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("This string contains ¥1 octal character.", AssertStringToken(token).Data);
        }
Example #8
0
        public void FallsBackToUnescapedForEarlyPdfTypes()
        {
            const string s = "/Priorto1.2#INvalidHexHash";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("Priorto1.2#INvalidHexHash", AssertNameToken(token).Data);
        }
Example #9
0
        public void ParsesComment(string s, string expected)
        {
            var input = StringBytesTestConverter.Convert(s);

            var result = commentTokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var comment = Assert.IsType <CommentToken>(token);

            Assert.Equal(expected, comment.Data);
        }
Example #10
0
        public void ConvertsFullOctal()
        {
            const string s = @"(This string contains \245two octal characters\307.)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("This string contains ¥two octal charactersÇ.", AssertStringToken(token).Data);
        }
        public void SkipsWhitespaceInStartSymbols()
        {
            var input = StringBytesTestConverter.Convert("< < /Name (Barry Scott) >>");

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var dictionary = AssertDictionaryToken(token);

            AssertDictionaryEntry <StringToken, string>(dictionary, NameToken.Name, "Barry Scott");
        }
        public void SimpleNameDictionary()
        {
            var input = StringBytesTestConverter.Convert("<< /Type /Example>>");

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var dictionary = AssertDictionaryToken(token);

            AssertDictionaryEntry <NameToken, string>(dictionary, NameToken.Type, "Example");
        }
Example #13
0
        public void EmptyArray(string s)
        {
            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var array = AssertArrayToken(token);

            Assert.Empty(array.Data);
        }
Example #14
0
        public void CanParseCodespaceRange()
        {
            var input = StringBytesTestConverter.Convert(GoogleDocToUnicodeCmap, false);

            var cmap = cMapParser.Parse(input.Bytes, false);

            Assert.Equal(1, cmap.CodespaceRanges.Count);

            Assert.Equal(0, cmap.CodespaceRanges[0].StartInt);
            Assert.Equal(65535, cmap.CodespaceRanges[0].EndInt);
            Assert.Equal(2, cmap.CodespaceRanges[0].CodeLength);
        }
Example #15
0
        public void ReachesEndOfInputAssumesEndOfString()
        {
            const string s = @"(this does not end with bracket";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(@"this does not end with bracket", AssertStringToken(token).Data);
        }
Example #16
0
        public void EscapedNonEscapeCharacterWritesPlainCharacter()
        {
            const string s = @"(this does not need escaping \e)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(@"this does not need escaping e", AssertStringToken(token).Data);
        }
Example #17
0
        public void HandlesEscapedBackslash()
        {
            const string s = @"(listen\\learn)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(@"listen\learn", AssertStringToken(token).Data);
        }
Example #18
0
        public void CanHandleAngleBrackets()
        {
            const string s = "(this string <contains>)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("this string <contains>", AssertStringToken(token).Data);
        }
Example #19
0
        public void ConvertsTwoPartialOctalsInARow()
        {
            const string s = @"(This string has two \53\326ctals)";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal("This string has two +Öctals", AssertStringToken(token).Data);
        }
Example #20
0
        public void CanParseWithHex()
        {
            var input = StringBytesTestConverter.Scanner("<8141> <8147> <8141>");

            var builder = new CharacterMapBuilder();

            parser.Parse(new NumericToken(1), input, builder, false);

            Assert.Equal(7, builder.BaseFontCharacterMap.Count);

            Assert.Equal("腁", builder.BaseFontCharacterMap[33089]);
            Assert.Equal(char.ConvertFromUtf32(33090), builder.BaseFontCharacterMap[33090]);
        }
Example #21
0
        public void MissingNumericAfterStartXrefThrows()
        {
            var input = StringBytesTestConverter.Convert(@"11 0 obj
        << /Type/Font >>
endobj

startxref 
   ", false);

            Action action = () => parser.GetFirstCrossReferenceOffset(input.Bytes, new CoreTokenScanner(input.Bytes), false);

            Assert.Throws <PdfDocumentFormatException>(action);
        }
Example #22
0
        public void CanParseWithArray()
        {
            var input = StringBytesTestConverter.Scanner("<0003> <0004> [<0020> <0041>]");

            var builder = new CharacterMapBuilder();

            parser.Parse(new NumericToken(1), input, builder, false);

            Assert.Equal(2, builder.BaseFontCharacterMap.Count);

            Assert.Equal(" ", builder.BaseFontCharacterMap[3]);
            Assert.Equal("A", builder.BaseFontCharacterMap[4]);
        }
Example #23
0
        public void CanParseCidSystemInfoAndOtherInformation()
        {
            var input = StringBytesTestConverter.Convert(GoogleDocToUnicodeCmap, false);

            var cmap = cMapParser.Parse(input.Bytes, false);

            Assert.Equal("Adobe", cmap.Info.Registry);
            Assert.Equal("UCS", cmap.Info.Ordering);
            Assert.Equal(0, cmap.Info.Supplement);

            Assert.Equal("Adobe-Identity-UCS", cmap.Name);
            Assert.Equal(2, cmap.Type);
        }
Example #24
0
        public void ReadsHeaderWithBlankSpaceBefore()
        {
            const string input = @"     

%PDF-1.2";

            var scanner = StringBytesTestConverter.Scanner(input);

            var result = FileHeaderParser.Parse(scanner.scanner, scanner.bytes, false, log);

            Assert.Equal(1.2m, result.Version);
            Assert.Equal(TestEnvironment.IsUnixPlatform ? 7 : 9, result.OffsetInFile);
        }
Example #25
0
        public void StreamDictionary()
        {
            var input = StringBytesTestConverter.Convert("<< /Filter /FlateDecode /S 36 /Length 53 >>");

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var dictionary = AssertDictionaryToken(token);

            AssertDictionaryEntry <NameToken, CosName, NameToken, CosName>(dictionary, 0, CosName.FILTER, CosName.FLATE_DECODE);
            AssertDictionaryEntry <NameToken, CosName, NumericToken, decimal>(dictionary, 1, CosName.S, 36);
            AssertDictionaryEntry <NameToken, CosName, NumericToken, decimal>(dictionary, 2, CosName.LENGTH, 53);
        }
Example #26
0
        public void SingleElementArray(string s, object dataValue)
        {
            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var array = AssertArrayToken(token);

            Assert.Equal(1, array.Data.Count);

            Assert.Equal(dataValue, ((dynamic)token).Data[0].Data);
        }
Example #27
0
        public void StreamDictionary()
        {
            var input = StringBytesTestConverter.Convert("<< /Filter /FlateDecode /S 36 /Length 53 >>");

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            var dictionary = AssertDictionaryToken(token);

            AssertDictionaryEntry <NameToken, string>(dictionary, NameToken.Filter, NameToken.FlateDecode.Data);
            AssertDictionaryEntry <NumericToken, decimal>(dictionary, NameToken.S, 36);
            AssertDictionaryEntry <NumericToken, decimal>(dictionary, NameToken.Length, 53);
        }
Example #28
0
        public void SupportTicket29()
        {
            var input = StringBytesTestConverter.Convert("<< /Type /Page /Parent 4 0 R /MediaBox [ 0 0      \r\n   100.28 841.89 ] /Resources >>");

            tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            var dict = AssertDictionaryToken(token);

            var mediaBox = dict.Data["MediaBox"] as ArrayToken;

            Assert.NotNull(mediaBox);

            Assert.Equal(4, mediaBox.Length);
        }
Example #29
0
        public void TreatsEndLinesAsNewline()
        {
            const string s = "(So does this one.\n)";

            const string expected = "So does this one.\n";

            var input = StringBytesTestConverter.Convert(s);

            var result = tokenizer.TryTokenize(input.First, input.Bytes, out var token);

            Assert.True(result);

            Assert.Equal(expected, AssertStringToken(token).Data);
        }
Example #30
0
        public void InvalidTokensAfterStartXrefThrows()
        {
            var input = StringBytesTestConverter.Convert(@"11 0 obj
        << /Type/Font >>
endobj

startxref 
<< /Why (am i here?) >> 69
%EOF", false);

            Action action = () => FileTrailerParser.GetFirstCrossReferenceOffset(input.Bytes, new CoreTokenScanner(input.Bytes), false);

            Assert.Throws <PdfDocumentFormatException>(action);
        }