pax_global_header 0000666 0000000 0000000 00000000064 13126526344 0014520 g ustar 00root root 0000000 0000000 52 comment=aa5d604871c7dd8f2c98dedcbb3836c88b13b29b
Serpent-serpent-1.23/ 0000775 0000000 0000000 00000000000 13126526344 0014543 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.23/.gitignore 0000664 0000000 0000000 00000001511 13126526344 0016531 0 ustar 00root root 0000000 0000000 *.py[cod]
# C extensions
*.so
# Packages
*.idea
*.egg
*.egg-info
dist
build
eggs
parts
bin
target
var
sdist
develop-eggs
.installed.cfg
lib
lib64
# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
[Bb]in/
[Oo]bj/
build
target
# mstest test results
TestResults
TEST-*.xml
TestResult.xml
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.sln.docstates
# Build results
[Dd]ebug/
[Rr]elease/
x64/
*_i.c
*_p.c
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.log
*.vspscc
*.vssscc
.builds
*.nupkg
# Installer logs
pip-log.txt
# Unit test / coverage reports
.coverage
.tox
nosetests.xml
# Translations
*.mo
# Mr Developer
.mr.developer.cfg
.project
.pydevproject
# java
*.class
Serpent-serpent-1.23/.pylintrc 0000664 0000000 0000000 00000000200 13126526344 0016400 0 ustar 00root root 0000000 0000000 [MESSAGES CONTROL]
disable=missing-docstring
[BASIC]
include-naming-hint=yes
max-line-length=120
good-names=i,j,k,x,y,z,t,ex,_
Serpent-serpent-1.23/.travis.yml 0000664 0000000 0000000 00000000447 13126526344 0016661 0 ustar 00root root 0000000 0000000 language: python
python:
- "2.7"
- "3.3"
- "3.4"
- "3.5"
- "3.6"
- "pypy"
- "pypy3"
# Use fast travis build infrastructure explicitly
sudo: false
# Installation installs dependencies
install:
- pip install pytz
- pip install .
script: cd tests && python -bb test_serpent.py
Serpent-serpent-1.23/LICENSE 0000664 0000000 0000000 00000002056 13126526344 0015553 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2017 Irmen de Jong
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Serpent-serpent-1.23/Makefile 0000664 0000000 0000000 00000002212 13126526344 0016200 0 ustar 00root root 0000000 0000000 .PHONY: all dist install upload clean test check
all:
@echo "targets include sdist, wheel, upload, install, clean, test"
dist:
python setup.py sdist bdist_wheel
@echo "Look in the dist/ directory"
upload:
python setup.py sdist bdist_wheel upload
install:
python setup.py install
test:
cd tests && (PYTHONPATH=.. python -s test_serpent.py)
check:
flake8 --exclude .tox --ignore E501
clean:
@echo "Removing tox dirs, logfiles, .pyo/.pyc files..."
rm -rf .tox
find . -name __pycache__ -print0 | xargs -0 rm -rf
find . -name \*_log -print0 | xargs -0 rm -f
find . -name \*.log -print0 | xargs -0 rm -f
find . -name \*.pyo -print0 | xargs -0 rm -f
find . -name \*.pyc -print0 | xargs -0 rm -f
find . -name \*.class -print0 | xargs -0 rm -f
find . -name \*.DS_Store -print0 | xargs -0 rm -f
find . -name TEST-*.xml -print0 | xargs -0 rm -f
find . -name TestResult.xml -print0 | xargs -0 rm -f
rm -f MANIFEST
rm -rf build
rm -rf dotnet/Serpent/obj dotnet/Serpent.Test/obj
rm -rf dotnet/Serpent/bin dotnet/Serpent.Test/bin
find . -name '.#*' -print0 | xargs -0 rm -f
find . -name '#*#' -print0 | xargs -0 rm -f
@echo "clean!"
Serpent-serpent-1.23/README.md 0000664 0000000 0000000 00000011220 13126526344 0016016 0 ustar 00root root 0000000 0000000 Serpent serialization library (Python/.NET/Java)
================================================
[](https://saythanks.io/to/irmen)
[](https://travis-ci.org/irmen/Serpent)
[](https://pypi.python.org/pypi/Serpent/)
[](http://search.maven.org/#search|ga|1|g%3A%22net.razorvine%22%20AND%20a%3A%22serpent%22)
[](https://www.nuget.org/packages/Razorvine.Serpent/)
[](https://anaconda.org/conda-forge/serpent)
Serpent provides ast.literal_eval() compatible object tree serialization.
It serializes an object tree into bytes (utf-8 encoded string) that can be decoded and then
passed as-is to ast.literal_eval() to rebuild it as the original object tree.
As such it is safe to send serpent data to other machines over the network for instance
(because only 'safe' literals are encoded).
More info on Pypi: https://pypi.python.org/pypi/serpent
Source code is on Github: https://github.com/irmen/Serpent
Copyright by Irmen de Jong (irmen@razorvine.net)
This software is released under the MIT software license.
This license, including disclaimer, is available in the 'LICENSE' file.
PYTHON
------
Package can be found on Pypi as 'serpent': https://pypi.python.org/pypi/serpent
Example usage can be found in ./tests/example.py
C#/.NET
-------
Package is available on www.nuget.org as 'Razorvine.Serpent'.
Full source code can be found in ./dotnet/ directory.
Example usage can be found in ./dotnet/Serpent.Test/Example.cs
JAVA
----
Maven-artefact is available on maven central, groupid 'net.razorvine' artifactid 'serpent'.
Full source code can be found in ./java/ directory.
Example usage can be found in ./java/test/SerpentExample.java
Versions before 1.23 require Java 7 or Java 8 (JDK 1.7 or 1.8) to compile and run.
Version 1.23 and later require Java 8 (JDK 1.8) at a minimum to compile and run.
SOME MORE DETAILS
-----------------
Compatible with Python 2.7+ (including 3.x), IronPython 2.7+, Jython 2.7+.
Serpent handles several special Python types to make life easier:
- str --> promoted to unicode (see below why this is)
- bytes, bytearrays, memoryview, buffer --> string, base-64
(you'll have to manually un-base64 them though. Can use serpent.tobytes function)
- uuid.UUID, datetime.{datetime, date, time, timespan} --> appropriate string/number
- decimal.Decimal --> string (to not lose precision)
- array.array typecode 'c'/'u' --> string/unicode
- array.array other typecode --> list
- Exception --> dict with some fields of the exception (message, args)
- collections module types --> mostly equivalent primitive types or dict
- enums --> the value of the enum (Python 3.4+)
- all other types --> dict with the ``__getstate__`` or ``vars()`` of the object
Notes:
All str will be promoted to unicode. This is done because it is the
default anyway for Python 3.x, and it solves the problem of the str/unicode
difference between different Python versions. Also it means the serialized
output doesn't have those problematic 'u' prefixes on strings.
The serializer is not thread-safe. Make sure you're not making changes
to the object tree that is being serialized, and don't use the same
serializer in different threads.
Because the serialized format is just valid Python source code, it can
contain comments. Serpent does not add comments by itself apart from the
single header line.
Set literals are not supported on python <3.2 (``ast.literal_eval``
limitation). If you need Python < 3.2 compatibility, you'll have to use
``set_literals=False`` when serializing. Since version 1.6 serpent chooses
this wisely for you by default, but you can still override it if needed.
Floats +inf and -inf are handled via a trick, Float 'nan' cannot be handled
and is represented by the special value: ``{'__class__':'float','value':'nan'}``
We chose not to encode it as just the string 'NaN' because that could cause
memory issues when used in multiplications.
Jython's ast module cannot properly parse some literal reprs of unicode strings.
This is a known bug http://bugs.jython.org/issue2008
It seems to work when your server is Python 2.x but safest is perhaps to make
sure your data to parse contains only ascii strings when dealing with Jython.
Serpent checks for possible problems and will raise an error if it finds one,
rather than continuing with string data that might be incorrect.
Serpent-serpent-1.23/dotnet/ 0000775 0000000 0000000 00000000000 13126526344 0016040 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.23/dotnet/Serpent.Test/ 0000775 0000000 0000000 00000000000 13126526344 0020376 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.23/dotnet/Serpent.Test/CycleTest.cs 0000664 0000000 0000000 00000005054 13126526344 0022630 0 ustar 00root root 0000000 0000000 ///
/// Serpent, a Python literal expression serializer/deserializer
/// (a.k.a. Python's ast.literal_eval in .NET)
///
/// Copyright Irmen de Jong (irmen@razorvine.net)
/// Software license: "MIT software license". See http://opensource.org/licenses/MIT
///
using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
namespace Razorvine.Serpent.Test
{
[TestFixture]
public class CycleTest
{
[Test]
public void testTupleOk()
{
var ser = new Serializer();
var t = new int[] {1,2,3};
var d = new object[] {t,t,t};
var data = ser.Serialize(d);
var parser = new Parser();
var ast = parser.Parse(data);
}
[Test]
public void testListOk()
{
var ser = new Serializer();
var t = new List();
t.Add(1);
t.Add(2);
t.Add(3);
var d = new List();
d.Add(t);
d.Add(t);
d.Add(t);
var data = ser.Serialize(d);
var parser = new Parser();
var ast = parser.Parse(data);
}
[Test]
public void testDictOk()
{
var ser = new Serializer();
var t = new Hashtable();
t["a"] = 1;
var d = new Hashtable();
d["x"] = t;
d["y"] = t;
d["z"] = t;
var data = ser.Serialize(d);
var parser = new Parser();
var ast = parser.Parse(data);
}
[Test]
[ExpectedException(typeof(ArgumentException))]
public void testListCycle()
{
var ser = new Serializer();
var d = new List();
d.Add(1);
d.Add(2);
d.Add(d);
var data = ser.Serialize(d);
}
[Test]
[ExpectedException(typeof(ArgumentException))]
public void testDictCycle()
{
var ser = new Serializer();
var d = new Hashtable();
d["x"] = 1;
d["y"] = 2;
d["z"] = d;
var data = ser.Serialize(d);
}
[Test]
[ExpectedException(typeof(ArgumentException))]
public void testClassCycle()
{
var ser = new Serializer();
var d = new SerializeTestClass();
d.x = 42;
d.i = 99;
d.s = "hello";
d.obj = d;
var data = ser.Serialize(d);
}
[Test]
public void testMaxLevel()
{
Serializer ser = new Serializer();
Assert.AreEqual(500, ser.MaximumLevel);
Object[] array = new Object[] {
"level1",
new Object[] {
"level2",
new Object[] {
"level3",
new Object[] {
"level 4"
}
}
}
};
ser.MaximumLevel = 4;
ser.Serialize(array); // should work
ser.MaximumLevel = 3;
try {
ser.Serialize(array);
Assert.Fail("should fail");
} catch(ArgumentException x) {
Assert.IsTrue(x.Message.Contains("too deep"));
}
}
}
}
Serpent-serpent-1.23/dotnet/Serpent.Test/Example.cs 0000664 0000000 0000000 00000005750 13126526344 0022327 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.IO;
using NUnit.Framework;
using Razorvine.Serpent;
namespace Razorvine.Serpent.Test
{
///
/// Example usage.
///
[TestFixture]
[Explicit("example")]
public class Example
{
[Test]
public void ExampleUsage()
{
Console.WriteLine("using serpent library version {0}", LibraryVersion.Version);
var data = new Dictionary {
{"tuple", new int[] { 1,2,3 } },
{"date", DateTime.Now},
{"set", new HashSet { "a", "b", "c" } },
{"class", new SampleClass() {
name = "Sally",
age = 26
}}
};
// serialize data structure to bytes
Serializer serpent = new Serializer(indent: true);
byte[] ser = serpent.Serialize(data);
// print it on the screen, but normally you'd store byte bytes in a file or transfer them across a network connection
Console.WriteLine("Serialized:");
Console.WriteLine(Encoding.UTF8.GetString(ser));
// parse the serialized bytes back into an abstract syntax tree of the datastructure
Parser parser = new Parser();
Ast ast = parser.Parse(ser);
Console.WriteLine("\nParsed AST:");
Console.WriteLine(ast.Root.ToString());
// print debug representation
DebugVisitor dv = new DebugVisitor();
ast.Accept(dv);
Console.WriteLine("DEBUG string representation:");
Console.WriteLine(dv.ToString());
// turn the Ast into regular .net objects
var dict = (IDictionary) ast.GetData();
// You can get the data out of the Ast manually as well, by using the supplied visitor:
// var visitor = new ObjectifyVisitor();
// ast.Accept(visitor);
// var dict = (IDictionary) visitor.GetObject();
// print the results
Console.WriteLine("PARSED results:");
Console.Write("tuple items: ");
object[] tuple = (object[]) dict["tuple"];
Console.WriteLine(string.Join(", ", tuple.Select(e=>e.ToString()).ToArray()));
Console.WriteLine("date: {0}", dict["date"]);
Console.Write("set items: ");
HashSet set = (HashSet) dict["set"];
Console.WriteLine(string.Join(", ", set.Select(e=>e.ToString()).ToArray()));
Console.WriteLine("class attributes:");
var clazz = (IDictionary) dict["class"]; // custom classes are serialized as dicts
Console.WriteLine(" type: {0}", clazz["__class__"]);
Console.WriteLine(" name: {0}", clazz["name"]);
Console.WriteLine(" age: {0}", clazz["age"]);
Console.WriteLine("");
// parse and print the example file
ser=File.ReadAllBytes("testserpent.utf8.bin");
ast = parser.Parse(ser);
dv = new DebugVisitor();
ast.Accept(dv);
Console.WriteLine("DEBUG string representation of the test file:");
Console.WriteLine(dv.ToString());
}
[Serializable]
public class SampleClass
{
public int age {get;set;}
public string name {get;set;}
}
}
}
Serpent-serpent-1.23/dotnet/Serpent.Test/ParserTest.cs 0000664 0000000 0000000 00000070006 13126526344 0023024 0 ustar 00root root 0000000 0000000 ///
/// Serpent, a Python literal expression serializer/deserializer
/// (a.k.a. Python's ast.literal_eval in .NET)
///
/// Copyright Irmen de Jong (irmen@razorvine.net)
/// Software license: "MIT software license". See http://opensource.org/licenses/MIT
///
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using NUnit.Framework;
namespace Razorvine.Serpent.Test
{
[TestFixture]
public class ParserTest
{
[Test]
public void TestBasic()
{
Parser p = new Parser();
Assert.IsNull(p.Parse((string)null).Root);
Assert.IsNull(p.Parse("").Root);
Assert.IsNotNull(p.Parse("# comment\n42\n").Root);
}
[Test]
public void TestComments()
{
Parser p = new Parser();
Ast ast = p.Parse("[ 1, 2 ]"); // no header whatsoever
var visitor = new ObjectifyVisitor();
ast.Accept(visitor);
Object obj = visitor.GetObject();
Assert.AreEqual(new int[] {1,2}, obj);
ast = p.Parse(@"# serpent utf-8 python2.7
[ 1, 2,
# some comments here
3, 4] # more here
# and here.
");
visitor = new ObjectifyVisitor();
ast.Accept(visitor);
obj = visitor.GetObject();
Assert.AreEqual(new int[] {1,2,3,4}, obj);
}
[Test]
public void TestPrimitives()
{
Parser p = new Parser();
Assert.AreEqual(new Ast.IntegerNode(42), p.Parse("42").Root);
Assert.AreEqual(new Ast.IntegerNode(-42), p.Parse("-42").Root);
Assert.AreEqual(new Ast.DoubleNode(42.331), p.Parse("42.331").Root);
Assert.AreEqual(new Ast.DoubleNode(-42.331), p.Parse("-42.331").Root);
Assert.AreEqual(new Ast.DoubleNode(-1.2e19), p.Parse("-1.2e+19").Root);
Assert.AreEqual(new Ast.DoubleNode(-1.2e19), p.Parse("-1.2e19").Root);
Assert.AreEqual(new Ast.DoubleNode(0.0004), p.Parse("4e-4").Root);
Assert.AreEqual(new Ast.DoubleNode(40000), p.Parse("4e4").Root);
Assert.AreEqual(new Ast.BooleanNode(true), p.Parse("True").Root);
Assert.AreEqual(new Ast.BooleanNode(false), p.Parse("False").Root);
Assert.AreEqual(Ast.NoneNode.Instance, p.Parse("None").Root);
// long ints
Assert.AreEqual(new Ast.DecimalNode(123456789123456789123456789M), p.Parse("123456789123456789123456789").Root);
Assert.AreNotEqual(new Ast.LongNode(52), p.Parse("52").Root);
Assert.AreEqual(new Ast.LongNode(123456789123456789L), p.Parse("123456789123456789").Root);
Assert.Throws(()=>p.Parse("123456789123456789123456789123456789")); // overflow
}
[Test]
public void TestWeirdFloats()
{
Parser p = new Parser();
var d = (Ast.DoubleNode) p.Parse("1e30000").Root;
Assert.IsTrue(double.IsPositiveInfinity(d.Value));
d = (Ast.DoubleNode) p.Parse("-1e30000").Root;
Assert.IsTrue(double.IsNegativeInfinity(d.Value));
var tuple = (Ast.TupleNode) p.Parse("(1e30000,-1e30000,{'__class__':'float','value':'nan'})").Root;
Assert.AreEqual(3, tuple.Elements.Count);
d = (Ast.DoubleNode) tuple.Elements[0];
Assert.IsTrue(double.IsPositiveInfinity(d.Value));
d = (Ast.DoubleNode) tuple.Elements[1];
Assert.IsTrue(double.IsNegativeInfinity(d.Value));
d = (Ast.DoubleNode) tuple.Elements[2];
Assert.IsTrue(Double.IsNaN(d.Value));
var c = (Ast.ComplexNumberNode) p.Parse("(1e30000-1e30000j)").Root;
Assert.IsTrue(double.IsPositiveInfinity(c.Real));
Assert.IsTrue(double.IsNegativeInfinity(c.Imaginary));
}
[Test]
public void TestFloatPrecision()
{
Parser p = new Parser();
Serializer serpent = new Serializer();
var ser = serpent.Serialize(1.2345678987654321);
Ast.DoubleNode dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.AreEqual(1.2345678987654321.ToString(), dv.Value.ToString());
ser = serpent.Serialize(5555.12345678987656);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.AreEqual(5555.12345678987656.ToString(), dv.Value.ToString());
ser = serpent.Serialize(98765432123456.12345678987656);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.AreEqual(98765432123456.12345678987656.ToString(), dv.Value.ToString());
ser = serpent.Serialize(98765432123456.12345678987656e+44);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.AreEqual((98765432123456.12345678987656e+44).ToString(), dv.Value.ToString());
ser = serpent.Serialize(-98765432123456.12345678987656e-44);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.AreEqual((-98765432123456.12345678987656e-44).ToString(), dv.Value.ToString());
}
[Test]
public void TestEquality()
{
Ast.INode n1, n2;
n1 = new Ast.IntegerNode(42);
n2 = new Ast.IntegerNode(42);
Assert.AreEqual(n1, n2);
n2 = new Ast.IntegerNode(43);
Assert.AreNotEqual(n1, n2);
n1 = new Ast.StringNode("foo");
n2 = new Ast.StringNode("foo");
Assert.AreEqual(n1, n2);
n2 = new Ast.StringNode("bar");
Assert.AreNotEqual(n1, n2);
n1 = new Ast.ComplexNumberNode() {
Real=1.1,
Imaginary=2.2
};
n2 = new Ast.ComplexNumberNode() {
Real=1.1,
Imaginary=2.2
};
Assert.AreEqual(n1, n2);
n2 = new Ast.ComplexNumberNode() {
Real=1.1,
Imaginary=3.3
};
Assert.AreNotEqual(n1, n2);
n1=new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(42),
Value=new Ast.IntegerNode(42)
};
n2=new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(42),
Value=new Ast.IntegerNode(42)
};
Assert.AreEqual(n1, n2);
n1=new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(43),
Value=new Ast.IntegerNode(43)
};
Assert.AreNotEqual(n1,n2);
n1=Ast.NoneNode.Instance;
n2=Ast.NoneNode.Instance;
Assert.AreEqual(n1, n2);
n2=new Ast.IntegerNode(42);
Assert.AreNotEqual(n1, n2);
n1=new Ast.DictNode() {
Elements=new List() {
new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(42),
Value=new Ast.IntegerNode(42)
}
}
};
n2=new Ast.DictNode() {
Elements=new List() {
new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(42),
Value=new Ast.IntegerNode(42)
}
}
};
Assert.AreEqual(n1, n2);
n2=new Ast.DictNode() {
Elements=new List() {
new Ast.KeyValueNode() {
Key=new Ast.IntegerNode(42),
Value=new Ast.IntegerNode(43)
}
}
};
Assert.AreNotEqual(n1, n2);
n1=new Ast.ListNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
n2=new Ast.ListNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
Assert.AreEqual(n1,n2);
n2=new Ast.ListNode() {
Elements=new List() {
new Ast.IntegerNode(43)
}
};
Assert.AreNotEqual(n1,n2);
n1=new Ast.SetNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
n2=new Ast.SetNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
Assert.AreEqual(n1,n2);
n2=new Ast.SetNode() {
Elements=new List() {
new Ast.IntegerNode(43)
}
};
Assert.AreNotEqual(n1,n2);
n1=new Ast.TupleNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
n2=new Ast.TupleNode() {
Elements=new List() {
new Ast.IntegerNode(42)
}
};
Assert.AreEqual(n1,n2);
n2=new Ast.TupleNode() {
Elements=new List() {
new Ast.IntegerNode(43)
}
};
Assert.AreNotEqual(n1,n2);
}
[Test]
public void TestDictEquality()
{
Ast.DictNode dict1 = new Ast.DictNode();
Ast.KeyValueNode kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key1"),
Value=new Ast.IntegerNode(42)
};
dict1.Elements.Add(kv);
kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key2"),
Value=new Ast.IntegerNode(43)
};
dict1.Elements.Add(kv);
kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key3"),
Value=new Ast.IntegerNode(44)
};
dict1.Elements.Add(kv);
Ast.DictNode dict2 = new Ast.DictNode();
kv=new Ast.KeyValueNode(){
Key=new Ast.StringNode("key2"),
Value=new Ast.IntegerNode(43)
};
dict2.Elements.Add(kv);
kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key3"),
Value=new Ast.IntegerNode(44)
};
dict2.Elements.Add(kv);
kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key1"),
Value=new Ast.IntegerNode(42)
};
dict2.Elements.Add(kv);
Assert.AreEqual(dict1, dict2);
kv=new Ast.KeyValueNode() {
Key=new Ast.StringNode("key4"),
Value=new Ast.IntegerNode(45)
};
dict2.Elements.Add(kv);
Assert.AreNotEqual(dict1, dict2);
}
[Test]
public void TestSetEquality()
{
Ast.SetNode set1 = new Ast.SetNode();
set1.Elements.Add(new Ast.IntegerNode(1));
set1.Elements.Add(new Ast.IntegerNode(2));
set1.Elements.Add(new Ast.IntegerNode(3));
Ast.SetNode set2 = new Ast.SetNode();
set2.Elements.Add(new Ast.IntegerNode(2));
set2.Elements.Add(new Ast.IntegerNode(3));
set2.Elements.Add(new Ast.IntegerNode(1));
Assert.AreEqual(set1, set2);
set2.Elements.Add(new Ast.IntegerNode(0));
Assert.AreNotEqual(set1, set2);
}
[Test]
public void TestPrintSingle()
{
Parser p = new Parser();
// primitives
Assert.AreEqual("42", p.Parse("42").Root.ToString());
Assert.AreEqual("-42.331", p.Parse("-42.331").Root.ToString());
Assert.AreEqual("-42.0", p.Parse("-42.0").Root.ToString());
Assert.AreEqual("-2E+20", p.Parse("-2E20").Root.ToString());
Assert.AreEqual("2.0", p.Parse("2.0").Root.ToString());
Assert.AreEqual("1.2E+19", p.Parse("1.2e19").Root.ToString());
Assert.AreEqual("True", p.Parse("True").Root.ToString());
Assert.AreEqual("'hello'", p.Parse("'hello'").Root.ToString());
Assert.AreEqual("'\\n'", p.Parse("'\n'").Root.ToString());
Assert.AreEqual("'\\''", p.Parse("'\\''").Root.ToString());
Assert.AreEqual("'\"'", p.Parse("'\\\"'").Root.ToString());
Assert.AreEqual("'\"'", p.Parse("'\"'").Root.ToString());
Assert.AreEqual("'\\\\'", p.Parse("'\\\\'").Root.ToString());
Assert.AreEqual("None", p.Parse("None").Root.ToString());
string ustr = "'\u20ac\u2603'";
Assert.AreEqual(ustr, p.Parse(ustr).Root.ToString());
// complex
Assert.AreEqual("(0+2j)", p.Parse("2j").Root.ToString());
Assert.AreEqual("(-1.1-2.2j)", p.Parse("(-1.1-2.2j)").Root.ToString());
Assert.AreEqual("(1.1+2.2j)", p.Parse("(1.1+2.2j)").Root.ToString());
// long int
Assert.AreEqual("123456789123456789123456789", p.Parse("123456789123456789123456789").Root.ToString());
}
[Test]
public void TestPrintSeq()
{
Parser p=new Parser();
//tuple
Assert.AreEqual("()", p.Parse("()").Root.ToString());
Assert.AreEqual("(42,)", p.Parse("(42,)").Root.ToString());
Assert.AreEqual("(42,43)", p.Parse("(42,43)").Root.ToString());
// list
Assert.AreEqual("[]", p.Parse("[]").Root.ToString());
Assert.AreEqual("[42]", p.Parse("[42]").Root.ToString());
Assert.AreEqual("[42,43]", p.Parse("[42,43]").Root.ToString());
// set
Assert.AreEqual("{42}", p.Parse("{42}").Root.ToString());
Assert.AreEqual("{42,43}", p.Parse("{42,43,43,43}").Root.ToString());
// dict
Assert.AreEqual("{}", p.Parse("{}").Root.ToString());
Assert.AreEqual("{'a':42}", p.Parse("{'a': 42}").Root.ToString());
Assert.AreEqual("{'a':42,'b':43}", p.Parse("{'a': 42, 'b': 43}").Root.ToString());
Assert.AreEqual("{'a':42,'b':45}", p.Parse("{'a': 42, 'b': 43, 'b': 44, 'b': 45}").Root.ToString());
}
[Test]
public void TestInvalidPrimitives()
{
Parser p = new Parser();
Assert.Throws(()=>p.Parse("1+2"));
Assert.Throws(()=>p.Parse("1-2"));
Assert.Throws(()=>p.Parse("1.1+2.2"));
Assert.Throws(()=>p.Parse("1.1-2.2"));
Assert.Throws(()=>p.Parse("True+2"));
Assert.Throws(()=>p.Parse("False-2"));
Assert.Throws(()=>p.Parse("3j+2"));
Assert.Throws(()=>p.Parse("3j-2"));
Assert.Throws(()=>p.Parse("None+2"));
Assert.Throws(()=>p.Parse("None-2"));
}
[Test]
public void TestComplex()
{
Parser p = new Parser();
var cplx = new Ast.ComplexNumberNode() {
Real = 4.2,
Imaginary = 3.2
};
var cplx2 = new Ast.ComplexNumberNode() {
Real = 4.2,
Imaginary = 99
};
Assert.AreNotEqual(cplx, cplx2);
cplx2.Imaginary = 3.2;
Assert.AreEqual(cplx, cplx2);
Assert.AreEqual(cplx, p.Parse("(4.2+3.2j)").Root);
cplx.Real = 0;
Assert.AreEqual(cplx, p.Parse("(0+3.2j)").Root);
Assert.AreEqual(cplx, p.Parse("3.2j").Root);
Assert.AreEqual(cplx, p.Parse("+3.2j").Root);
cplx.Imaginary = -3.2;
Assert.AreEqual(cplx, p.Parse("-3.2j").Root);
cplx.Real = -9.9;
Assert.AreEqual(cplx, p.Parse("(-9.9-3.2j)").Root);
cplx.Real = 2;
cplx.Imaginary = 3;
Assert.AreEqual(cplx, p.Parse("(2+3j)").Root);
cplx.Imaginary = -3;
Assert.AreEqual(cplx, p.Parse("(2-3j)").Root);
cplx.Real = 0;
Assert.AreEqual(cplx, p.Parse("-3j").Root);
cplx.Real = -3.2e32;
cplx.Imaginary = -9.9e44;
Assert.AreEqual(cplx, p.Parse("(-3.2e32 -9.9e44j)").Root);
Assert.AreEqual(cplx, p.Parse("(-3.2e+32 -9.9e+44j)").Root);
Assert.AreEqual(cplx, p.Parse("(-3.2e32-9.9e44j)").Root);
Assert.AreEqual(cplx, p.Parse("(-3.2e+32-9.9e+44j)").Root);
cplx.Imaginary = 9.9e44;
Assert.AreEqual(cplx, p.Parse("(-3.2e32+9.9e44j)").Root);
Assert.AreEqual(cplx, p.Parse("(-3.2e+32+9.9e+44j)").Root);
cplx.Real = -3.2e-32;
cplx.Imaginary = -9.9e-44;
Assert.AreEqual(cplx, p.Parse("(-3.2e-32-9.9e-44j)").Root);
}
[Test]
public void TestComplexPrecision()
{
Parser p = new Parser();
Ast.ComplexNumberNode cv = (Ast.ComplexNumberNode)p.Parse("(98765432123456.12345678987656+665544332211.9998877665544j)").Root;
Assert.AreEqual(98765432123456.12345678987656, cv.Real);
Assert.AreEqual(665544332211.9998877665544, cv.Imaginary);
cv = (Ast.ComplexNumberNode)p.Parse("(98765432123456.12345678987656-665544332211.9998877665544j)").Root;
Assert.AreEqual(98765432123456.12345678987656, cv.Real);
Assert.AreEqual(-665544332211.9998877665544, cv.Imaginary);
cv = (Ast.ComplexNumberNode)p.Parse("(98765432123456.12345678987656e+33+665544332211.9998877665544e+44j)").Root;
Assert.AreEqual(98765432123456.12345678987656e+33, cv.Real);
Assert.AreEqual(665544332211.9998877665544e+44, cv.Imaginary);
cv = (Ast.ComplexNumberNode)p.Parse("(-98765432123456.12345678987656e+33-665544332211.9998877665544e+44j)").Root;
Assert.AreEqual(-98765432123456.12345678987656e+33, cv.Real);
Assert.AreEqual(-665544332211.9998877665544e+44, cv.Imaginary);
}
[Test]
public void TestPrimitivesStuffAtEnd()
{
Parser p = new Parser();
Assert.AreEqual(new Ast.IntegerNode(42), p.ParseSingle(new SeekableStringReader("42@")));
Assert.AreEqual(new Ast.DoubleNode(42.331), p.ParseSingle(new SeekableStringReader("42.331@")));
Assert.AreEqual(new Ast.BooleanNode(true), p.ParseSingle(new SeekableStringReader("True@")));
Assert.AreEqual(Ast.NoneNode.Instance, p.ParseSingle(new SeekableStringReader("None@")));
var cplx = new Ast.ComplexNumberNode() {
Real = 4,
Imaginary = 3
};
Assert.AreEqual(cplx, p.ParseSingle(new SeekableStringReader("(4+3j)@")));
cplx.Real=0;
Assert.AreEqual(cplx, p.ParseSingle(new SeekableStringReader("3j@")));
}
[Test]
public void TestStrings()
{
Parser p = new Parser();
Assert.AreEqual(new Ast.StringNode("hello"), p.Parse("'hello'").Root);
Assert.AreEqual(new Ast.StringNode("hello"), p.Parse("\"hello\"").Root);
Assert.AreEqual(new Ast.StringNode("\\"), p.Parse("'\\\\'").Root);
Assert.AreEqual(new Ast.StringNode("\\"), p.Parse("\"\\\\\"").Root);
Assert.AreEqual(new Ast.StringNode("'"), p.Parse("\"'\"").Root);
Assert.AreEqual(new Ast.StringNode("\""), p.Parse("'\"'").Root);
Assert.AreEqual(new Ast.StringNode("tab\tnewline\n."), p.Parse("'tab\\tnewline\\n.'").Root);
}
[Test]
public void TestUnicode()
{
Parser p = new Parser();
string str = "'\u20ac\u2603'";
Assert.AreEqual(0x20ac, str[1]);
Assert.AreEqual(0x2603, str[2]);
byte[] bytes = Encoding.UTF8.GetBytes(str);
string value = "\u20ac\u2603";
Assert.AreEqual(new Ast.StringNode(value), p.Parse(str).Root);
Assert.AreEqual(new Ast.StringNode(value), p.Parse(bytes).Root);
}
[Test]
public void TestLongUnicodeRoundtrip()
{
Char[] chars64k = new Char[65536];
for(int i=0; i<=65535; ++i)
chars64k[i]=(Char)i;
String str64k= new String(chars64k);
Serializer ser=new Serializer();
byte[] data = ser.Serialize(str64k);
Assert.Greater(data.Length, chars64k.Length);
Parser p=new Parser();
String result = (String)p.Parse(data).GetData();
Assert.AreEqual(str64k, result);
}
[Test]
public void TestWhitespace()
{
Parser p = new Parser();
Assert.AreEqual(new Ast.IntegerNode(42), p.Parse(" 42 ").Root);
Assert.AreEqual(new Ast.IntegerNode(42), p.Parse(" 42 ").Root);
Assert.AreEqual(new Ast.IntegerNode(42), p.Parse("\t42\r\n").Root);
Assert.AreEqual(new Ast.IntegerNode(42), p.Parse(" \t 42 \r \n ").Root);
Assert.AreEqual(new Ast.StringNode(" string value "), p.Parse(" ' string value ' ").Root);
Assert.Throws(()=>p.Parse(" ( 42 , ( 'x', 'y' ) ")); // missing tuple close )
Ast ast = p.Parse(" ( 42 , ( 'x', 'y' ) ) ");
Ast.TupleNode tuple = (Ast.TupleNode) ast.Root;
Assert.AreEqual(new Ast.IntegerNode(42), tuple.Elements[0]);
tuple = (Ast.TupleNode) tuple.Elements[1];
Assert.AreEqual(new Ast.StringNode("x"), tuple.Elements[0]);
Assert.AreEqual(new Ast.StringNode("y"), tuple.Elements[1]);
p.Parse(" ( 52 , ) ");
p.Parse(" [ 52 ] ");
p.Parse(" { 'a' : 42 } ");
p.Parse(" { 52 } ");
}
[Test]
public void TestTuple()
{
Parser p = new Parser();
Ast.TupleNode tuple = new Ast.TupleNode();
Ast.TupleNode tuple2 = new Ast.TupleNode();
Assert.AreEqual(tuple, tuple2);
tuple.Elements.Add(new Ast.IntegerNode(42));
tuple2.Elements.Add(new Ast.IntegerNode(99));
Assert.AreNotEqual(tuple, tuple2);
tuple2.Elements.Clear();
tuple2.Elements.Add(new Ast.IntegerNode(42));
Assert.AreEqual(tuple, tuple2);
tuple2.Elements.Add(new Ast.IntegerNode(43));
tuple2.Elements.Add(new Ast.IntegerNode(44));
Assert.AreNotEqual(tuple, tuple2);
Assert.AreEqual(new Ast.TupleNode(), p.Parse("()").Root);
Assert.AreEqual(tuple, p.Parse("(42,)").Root);
Assert.AreEqual(tuple2, p.Parse("( 42,43, 44 )").Root);
Assert.Throws(()=>p.Parse("(42,43]"));
Assert.Throws(()=>p.Parse("()@"));
Assert.Throws(()=>p.Parse("(42,43)@"));
}
[Test]
public void TestList()
{
Parser p = new Parser();
Ast.ListNode list = new Ast.ListNode();
Ast.ListNode list2 = new Ast.ListNode();
Assert.AreEqual(list, list2);
list.Elements.Add(new Ast.IntegerNode(42));
list2.Elements.Add(new Ast.IntegerNode(99));
Assert.AreNotEqual(list, list2);
list2.Elements.Clear();
list2.Elements.Add(new Ast.IntegerNode(42));
Assert.AreEqual(list, list2);
list2.Elements.Add(new Ast.IntegerNode(43));
list2.Elements.Add(new Ast.IntegerNode(44));
Assert.AreNotEqual(list, list2);
Assert.AreEqual(new Ast.ListNode(), p.Parse("[]").Root);
Assert.AreEqual(list, p.Parse("[42]").Root);
Assert.AreEqual(list2, p.Parse("[ 42,43, 44 ]").Root);
Assert.Throws(()=>p.Parse("[42,43}"));
Assert.Throws(()=>p.Parse("[]@"));
Assert.Throws(()=>p.Parse("[42,43]@"));
}
[Test]
public void TestSet()
{
Parser p = new Parser();
Ast.SetNode set1 = new Ast.SetNode();
Ast.SetNode set2 = new Ast.SetNode();
Assert.AreEqual(set1, set2);
set1.Elements.Add(new Ast.IntegerNode(42));
set2.Elements.Add(new Ast.IntegerNode(99));
Assert.AreNotEqual(set1, set2);
set2.Elements.Clear();
set2.Elements.Add(new Ast.IntegerNode(42));
Assert.AreEqual(set1, set2);
set2.Elements.Add(new Ast.IntegerNode(43));
set2.Elements.Add(new Ast.IntegerNode(44));
Assert.AreNotEqual(set1, set2);
Assert.AreEqual(set1, p.Parse("{42}").Root);
Assert.AreEqual(set2, p.Parse("{ 42,43, 44 }").Root);
Assert.Throws(()=>p.Parse("{42,43]"));
Assert.Throws(()=>p.Parse("{42,43}@"));
set1 = p.Parse("{'first','second','third','fourth','fifth','second', 'first', 'third', 'third' }").Root as Ast.SetNode;
Assert.AreEqual("'first'", set1.Elements[0].ToString());
Assert.AreEqual("'second'", set1.Elements[1].ToString());
Assert.AreEqual("'third'", set1.Elements[2].ToString());
Assert.AreEqual("'fourth'", set1.Elements[3].ToString());
Assert.AreEqual("'fifth'", set1.Elements[4].ToString());
Assert.AreEqual(5, set1.Elements.Count);
}
[Test]
public void TestDict()
{
Parser p = new Parser();
Ast.DictNode dict1 = new Ast.DictNode();
Ast.DictNode dict2 = new Ast.DictNode();
Assert.AreEqual(dict1, dict2);
Ast.KeyValueNode kv1 = new Ast.KeyValueNode { Key=new Ast.StringNode("key"), Value=new Ast.IntegerNode(42) };
Ast.KeyValueNode kv2 = new Ast.KeyValueNode { Key=new Ast.StringNode("key"), Value=new Ast.IntegerNode(99) };
Assert.AreNotEqual(kv1, kv2);
kv2.Value = new Ast.IntegerNode(42);
Assert.AreEqual(kv1, kv2);
dict1.Elements.Add(new Ast.KeyValueNode { Key=new Ast.StringNode("key1"), Value=new Ast.IntegerNode(42) });
dict2.Elements.Add(new Ast.KeyValueNode { Key=new Ast.StringNode("key1"), Value=new Ast.IntegerNode(99) });
Assert.AreNotEqual(dict1, dict2);
dict2.Elements.Clear();
dict2.Elements.Add(new Ast.KeyValueNode { Key=new Ast.StringNode("key1"), Value=new Ast.IntegerNode(42) });
Assert.AreEqual(dict1, dict2);
dict2.Elements.Add(new Ast.KeyValueNode { Key=new Ast.StringNode("key2"), Value=new Ast.IntegerNode(43) });
dict2.Elements.Add(new Ast.KeyValueNode { Key=new Ast.StringNode("key3"), Value=new Ast.IntegerNode(44) });
Assert.AreNotEqual(dict1, dict2);
Assert.AreEqual(new Ast.DictNode(), p.Parse("{}").Root);
Assert.AreEqual(dict1, p.Parse("{'key1': 42}").Root);
Assert.AreEqual(dict2, p.Parse("{'key1': 42, 'key2': 43, 'key3':44}").Root);
Assert.Throws(()=>p.Parse("{'key': 42]"));
Assert.Throws(()=>p.Parse("{}@"));
Assert.Throws(()=>p.Parse("{'key': 42}@"));
dict1 = p.Parse("{'a': 1, 'b': 2, 'c': 3, 'c': 4, 'c': 5, 'c': 6}").Root as Ast.DictNode;
Assert.AreEqual("'a':1", dict1.Elements[0].ToString());
Assert.AreEqual("'b':2", dict1.Elements[1].ToString());
Assert.AreEqual("'c':6", dict1.Elements[2].ToString());
Assert.AreEqual(3, dict1.Elements.Count);
}
[Test]
public void TestFile()
{
Parser p = new Parser();
byte[] ser=File.ReadAllBytes("testserpent.utf8.bin");
Ast ast = p.Parse(ser);
string expr = ast.ToString();
Ast ast2 = p.Parse(expr);
string expr2 = ast2.ToString();
Assert.AreEqual(expr, expr2);
StringBuilder sb= new StringBuilder();
Walk(ast.Root, sb);
string walk1 = sb.ToString();
sb= new StringBuilder();
Walk(ast2.Root, sb);
string walk2 = sb.ToString();
Assert.AreEqual(walk1, walk2);
// @TODO Assert.AreEqual(ast.Root, ast2.Root);
ast = p.Parse(expr2);
// @TODO Assert.AreEqual(ast.Root, ast2.Root);
}
[Test]
[Ignore("can't yet get the ast to compare equal on mono")]
public void TestAstEquals()
{
Parser p = new Parser ();
byte[] ser = File.ReadAllBytes ("testserpent.utf8.bin");
Ast ast = p.Parse(ser);
Ast ast2 = p.Parse(ser);
Assert.AreEqual(ast.Root, ast2.Root);
}
public void Walk(Ast.INode node, StringBuilder sb)
{
if(node is Ast.SequenceNode)
{
sb.AppendLine(string.Format("{0} (seq)", node.GetType()));
Ast.SequenceNode seq = (Ast.SequenceNode)node;
foreach(Ast.INode child in seq.Elements) {
Walk(child, sb);
}
}
else
sb.AppendLine(string.Format("{0} = {1}", node.GetType(), node.ToString()));
}
[Test]
public void TestTrailingCommas()
{
Parser p = new Parser();
Ast.INode result;
result = p.Parse("[1,2,3, ]").Root;
result = p.Parse("[1,2,3 , ]").Root;
result = p.Parse("[1,2,3,]").Root;
Assert.AreEqual("[1,2,3]", result.ToString());
result = p.Parse("(1,2,3, )").Root;
result = p.Parse("(1,2,3 , )").Root;
result = p.Parse("(1,2,3,)").Root;
Assert.AreEqual("(1,2,3)", result.ToString());
// for dict and set the asserts are a bit more complex
// we cannot simply convert to string because the order of elts is undefined.
result = p.Parse("{'a':1, 'b':2, 'c':3, }").Root;
result = p.Parse("{'a':1, 'b':2, 'c':3 , }").Root;
result = p.Parse("{'a':1, 'b':2, 'c':3,}").Root;
Ast.DictNode dict = (Ast.DictNode) result;
var items = dict.ElementsAsSet();
Assert.IsTrue(items.Contains(new Ast.KeyValueNode(new Ast.StringNode("a"), new Ast.IntegerNode(1))));
Assert.IsTrue(items.Contains(new Ast.KeyValueNode(new Ast.StringNode("b"), new Ast.IntegerNode(2))));
Assert.IsTrue(items.Contains(new Ast.KeyValueNode(new Ast.StringNode("c"), new Ast.IntegerNode(3))));
result = p.Parse("{1,2,3, }").Root;
result = p.Parse("{1,2,3 , }").Root;
result = p.Parse("{1,2,3,}").Root;
Ast.SetNode set = (Ast.SetNode) result;
items = set.ElementsAsSet();
Assert.IsTrue(items.Contains(new Ast.IntegerNode(1)));
Assert.IsTrue(items.Contains(new Ast.IntegerNode(2)));
Assert.IsTrue(items.Contains(new Ast.IntegerNode(3)));
Assert.IsFalse(items.Contains(new Ast.IntegerNode(4)));
}
}
[TestFixture]
public class VisitorTest
{
[Test]
public void TestObjectify()
{
Parser p = new Parser();
byte[] ser=File.ReadAllBytes("testserpent.utf8.bin");
Ast ast = p.Parse(ser);
var visitor = new ObjectifyVisitor();
ast.Accept(visitor);
object thing = visitor.GetObject();
IDictionary dict = (IDictionary) thing;
Assert.AreEqual(11, dict.Count);
IList list = dict["numbers"] as IList;
Assert.AreEqual(4, list.Count);
Assert.AreEqual(999.1234, list[1]);
Assert.AreEqual(new ComplexNumber(-3, 8), list[3]);
string euro = dict["unicode"] as string;
Assert.AreEqual("\u20ac", euro);
IDictionary exc = (IDictionary)dict["exc"];
object[] args = (object[]) exc["args"];
Assert.AreEqual("fault", args[0]);
Assert.AreEqual("ZeroDivisionError", exc["__class__"]);
}
object ZerodivisionFromDict(IDictionary dict)
{
string classname = (string)dict["__class__"];
if(classname=="ZeroDivisionError")
{
object[] args = (object[]) dict["args"];
return new DivideByZeroException((string)args[0]);
}
return null;
}
[Test]
public void TestObjectifyDictToClass()
{
Parser p = new Parser();
byte[] ser=File.ReadAllBytes("testserpent.utf8.bin");
Ast ast = p.Parse(ser);
var visitor = new ObjectifyVisitor(ZerodivisionFromDict);
ast.Accept(visitor);
object thing = visitor.GetObject();
IDictionary dict = (IDictionary) thing;
Assert.AreEqual(11, dict.Count);
DivideByZeroException ex = (DivideByZeroException) dict["exc"];
Assert.AreEqual("fault", ex.Message);
thing = ast.GetData(ZerodivisionFromDict);
dict = (IDictionary) thing;
Assert.AreEqual(11, dict.Count);
ex = (DivideByZeroException) dict["exc"];
Assert.AreEqual("fault", ex.Message);
}
}
} Serpent-serpent-1.23/dotnet/Serpent.Test/Properties/ 0000775 0000000 0000000 00000000000 13126526344 0022532 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.23/dotnet/Serpent.Test/Properties/AssemblyInfo.cs 0000664 0000000 0000000 00000002043 13126526344 0025453 0 ustar 00root root 0000000 0000000 #region Using directives
using System;
using System.Reflection;
using System.Runtime.InteropServices;
#endregion
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Serpent.Test")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Serpent.Test")]
[assembly: AssemblyCopyright("Copyright Irmen de Jong")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// This sets the default COM visibility of types in the assembly to invisible.
// If you need to expose a type to COM, use [ComVisible(true)] on that type.
[assembly: ComVisible(false)]
// The assembly version has following format :
//
// Major.Minor.Build.Revision
//
// You can specify all the values or you can use the default the Revision and
// Build Numbers by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")]
Serpent-serpent-1.23/dotnet/Serpent.Test/SerializeTest.cs 0000664 0000000 0000000 00000056516 13126526344 0023531 0 ustar 00root root 0000000 0000000 ///
/// Serpent, a Python literal expression serializer/deserializer
/// (a.k.a. Python's ast.literal_eval in .NET)
///
/// Copyright Irmen de Jong (irmen@razorvine.net)
/// Software license: "MIT software license". See http://opensource.org/licenses/MIT
///
using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using Hashtable = System.Collections.Hashtable;
using IDictionary = System.Collections.IDictionary;
namespace Razorvine.Serpent.Test
{
[TestFixture]
public class SerializeTest
{
public byte[] strip_header(byte[] data)
{
int start=Array.IndexOf(data, (byte)10); // the newline after the header
if(start<0)
throw new ArgumentException("need header in string");
start++;
byte[] result = new byte[data.Length-start];
Array.Copy(data, start, result, 0, data.Length-start);
return result;
}
public byte[] B(string s)
{
return Encoding.UTF8.GetBytes(s);
}
public string S(byte[] b)
{
return Encoding.UTF8.GetString(b);
}
[Test]
public void TestHeader()
{
Serializer ser = new Serializer();
byte[] data = ser.Serialize(null);
Assert.AreEqual(35, data[0]);
string strdata = S(data);
Assert.AreEqual("# serpent utf-8 python3.2", strdata.Split('\n')[0]);
ser.SetLiterals=false;
data = ser.Serialize(null);
strdata = S(data);
Assert.AreEqual("# serpent utf-8 python2.6", strdata.Split('\n')[0]);
data = B("# header\nfirst-line");
data = strip_header(data);
Assert.AreEqual(B("first-line"), data);
}
[Test]
public void TestStuff()
{
Serializer ser=new Serializer();
byte[] result = ser.Serialize("blerp");
result=strip_header(result);
Assert.AreEqual(B("'blerp'"), result);
result = ser.Serialize(new Guid("f1f8d00e-49a5-4662-ac1d-d5f0426ed293"));
result=strip_header(result);
Assert.AreEqual(B("'f1f8d00e-49a5-4662-ac1d-d5f0426ed293'"), result);
result = ser.Serialize(123456789.987654321987654321987654321987654321m);
result=strip_header(result);
Assert.AreEqual(B("'123456789.98765432198765432199'"), result);
}
[Test]
public void TestNull()
{
Serializer ser = new Serializer();
byte[] data = ser.Serialize(null);
data=strip_header(data);
Assert.AreEqual(B("None"),data);
}
[Test]
public void TestStrings()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.Serialize("hello");
byte[] data = strip_header(ser);
Assert.AreEqual(B("'hello'"), data);
ser = serpent.Serialize("quotes'\"");
data = strip_header(ser);
Assert.AreEqual(B("'quotes\\'\"'"), data);
ser = serpent.Serialize("quotes2'");
data = strip_header(ser);
Assert.AreEqual(B("\"quotes2'\""), data);
}
[Test]
public void TestUnicodeEscapes()
{
Serializer serpent=new Serializer();
// regular escaped chars first
byte[] ser = serpent.Serialize("\b\r\n\f\t \\");
byte[] data = strip_header(ser);
// '\\x08\\r\\n\\x0c\\t \\\\'
Assert.AreEqual(new byte[] {39,
92, 120, 48, 56,
92, 114,
92, 110,
92, 120, 48, 99,
92, 116,
32,
92, 92,
39}, data);
// simple cases (chars < 0x80)
ser = serpent.Serialize("\u0000\u0001\u001f\u007f");
data = strip_header(ser);
// '\\x00\\x01\\x1f\\x7f'
Assert.AreEqual(new byte[] {39,
92, 120, 48, 48,
92, 120, 48, 49,
92, 120, 49, 102,
92, 120, 55, 102,
39 }, data);
// chars 0x80 .. 0xff
ser = serpent.Serialize("\u0080\u0081\u00ff");
data = strip_header(ser);
// '\\x80\\x81\xc3\xbf' (has some utf-8 encoded chars in it)
Assert.AreEqual(new byte[] {39,
92, 120, 56, 48,
92, 120, 56, 49,
195, 191,
39}, data);
// chars above 0xff
ser = serpent.Serialize("\u0100\u20ac\u8899");
data = strip_header(ser);
// '\xc4\x80\xe2\x82\xac\xe8\xa2\x99' (has some utf-8 encoded chars in it)
Assert.AreEqual(new byte[] {39, 196, 128, 226, 130, 172, 232, 162, 153, 39}, data);
// // some random high chars that are all printable in python and not escaped
// ser = serpent.Serialize("\u0377\u082d\u10c5\u135d\uac00");
// data = strip_header(ser);
// Console.WriteLine(S(data)); // XXX
// // '\xcd\xb7\xe0\xa0\xad\xe1\x83\x85\xe1\x8d\x9d\xea\xb0\x80' (only a bunch of utf-8 encoded chars)
// Assert.AreEqual(new byte[] {39, 205, 183, 224, 160, 173, 225, 131, 133, 225, 141, 157, 234, 176, 128, 39}, data);
// some random high chars that are all non-printable in python and that are escaped
ser = serpent.Serialize("\u0378\u082e\u10c6\u135c\uabff");
data = strip_header(ser);
// '\\u0378\\u082e\\u10c6\\u135c\\uabff'
Assert.AreEqual(new byte[] {39,
92, 117, 48, 51, 55, 56,
92, 117, 48, 56, 50, 101,
92, 117, 49, 48, 99, 54,
92, 117, 49, 51, 53, 99,
92, 117, 97, 98, 102, 102,
39}, data);
}
[Test]
public void TestNumbers()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.Serialize((int)12345);
byte[] data = strip_header(ser);
Assert.AreEqual(B("12345"), data);
ser = serpent.Serialize((uint)12345);
data = strip_header(ser);
Assert.AreEqual(B("12345"), data);
ser = serpent.Serialize((long)1234567891234567891L);
data = strip_header(ser);
Assert.AreEqual(B("1234567891234567891"), data);
ser = serpent.Serialize((ulong)12345678912345678912L);
data = strip_header(ser);
Assert.AreEqual(B("12345678912345678912"), data);
ser = serpent.Serialize(99.1234);
data = strip_header(ser);
Assert.AreEqual(B("99.1234"), data);
ser = serpent.Serialize(1234.9999999999m);
data = strip_header(ser);
Assert.AreEqual(B("'1234.9999999999'"), data);
ser = serpent.Serialize(123456789.987654321987654321987654321987654321m);
data=strip_header(ser);
Assert.AreEqual(B("'123456789.98765432198765432199'"), data);
ComplexNumber cplx = new ComplexNumber(2.2, 3.3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.AreEqual(B("(2.2+3.3j)"), data);
cplx = new ComplexNumber(0, 3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.AreEqual(B("(0+3j)"), data);
cplx = new ComplexNumber(-2, -3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.AreEqual(B("(-2-3j)"), data);
}
[Test]
public void TestDoubleNanInf()
{
Serializer serpent = new Serializer();
var doubles = new object[] {double.PositiveInfinity, double.NegativeInfinity, double.NaN,
float.PositiveInfinity, float.NegativeInfinity, float.NaN,
new ComplexNumber(double.PositiveInfinity, 3.4)};
byte[] ser = serpent.Serialize(doubles);
byte[] data = strip_header(ser);
Assert.AreEqual("(1e30000,-1e30000,{'__class__':'float','value':'nan'},1e30000,-1e30000,{'__class__':'float','value':'nan'},(1e30000+3.4j))", S(data));
}
[Test]
public void TestBool()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.Serialize(true);
byte[] data = strip_header(ser);
Assert.AreEqual(B("True"),data);
ser = serpent.Serialize(false);
data = strip_header(ser);
Assert.AreEqual(B("False"),data);
}
[Test]
public void TestList()
{
Serializer serpent = new Serializer();
IList list = new List();
// test empty list
byte[] ser = strip_header(serpent.Serialize(list));
Assert.AreEqual("[]", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(list));
Assert.AreEqual("[]", S(ser));
serpent.Indent=false;
// test nonempty list
list.Add(42);
list.Add("Sally");
list.Add(16.5);
ser = strip_header(serpent.Serialize(list));
Assert.AreEqual("[42,'Sally',16.5]", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(list));
Assert.AreEqual("[\n 42,\n 'Sally',\n 16.5\n]", S(ser));
}
[Test]
public void TestSet()
{
// test with set literals
Serializer serpent = new Serializer();
serpent.SetLiterals = true;
HashSet set = new HashSet();
// test empty set
byte[] ser = strip_header(serpent.Serialize(set));
Assert.AreEqual("()", S(ser)); // empty set is serialized as a tuple.
serpent.Indent=true;
ser = strip_header(serpent.Serialize(set));
Assert.AreEqual("()", S(ser)); // empty set is serialized as a tuple.
serpent.Indent=false;
// test nonempty set
set.Add(42);
set.Add("Sally");
set.Add(16.5);
ser = strip_header(serpent.Serialize(set));
Assert.AreEqual("{42,'Sally',16.5}", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(set));
Assert.AreEqual("{\n 42,\n 'Sally',\n 16.5\n}", S(ser));
// test no set literals
serpent.Indent=false;
serpent.SetLiterals=false;
ser = strip_header(serpent.Serialize(set));
Assert.AreEqual("(42,'Sally',16.5)", S(ser)); // needs to be tuple now
}
[Test]
public void TestDictionary()
{
Serializer serpent = new Serializer();
Parser p = new Parser();
// test empty dict
IDictionary ht = new Hashtable();
byte[] ser = serpent.Serialize(ht);
Assert.AreEqual(B("{}"), strip_header(ser));
string parsed = p.Parse(ser).Root.ToString();
Assert.AreEqual("{}", parsed);
// empty dict with indentation
serpent.Indent=true;
ser = serpent.Serialize(ht);
Assert.AreEqual(B("{}"), strip_header(ser));
parsed = p.Parse(ser).Root.ToString();
Assert.AreEqual("{}", parsed);
// test dict with values
serpent.Indent=false;
ht = new Hashtable() {
{42, "fortytwo"},
{"sixteen-and-half", 16.5},
{"name", "Sally"},
{"status", false}
};
ser = serpent.Serialize(ht);
Assert.AreEqual('}', ser[ser.Length-1]);
Assert.AreNotEqual(',', ser[ser.Length-2]);
parsed = p.Parse(ser).Root.ToString();
Assert.AreEqual(69, parsed.Length);
// test indentation
serpent.Indent=true;
ser = serpent.Serialize(ht);
Assert.AreEqual('}', ser[ser.Length-1]);
Assert.AreEqual('\n', ser[ser.Length-2]);
Assert.AreNotEqual(',', ser[ser.Length-3]);
string ser_str = S(strip_header(ser));
Assert.IsTrue(ser_str.Contains("'name': 'Sally'"));
Assert.IsTrue(ser_str.Contains("'status': False"));
Assert.IsTrue(ser_str.Contains("42: 'fortytwo'"));
Assert.IsTrue(ser_str.Contains("'sixteen-and-half': 16.5"));
parsed = p.Parse(ser).Root.ToString();
Assert.AreEqual(69, parsed.Length);
serpent.Indent=false;
// generic Dictionary test
IDictionary mydict = new Dictionary {
{ 1, "one" },
{ 2, "two" },
};
ser = serpent.Serialize(mydict);
ser_str = S(strip_header(ser));
Assert.IsTrue(ser_str=="{2:'two',1:'one'}" || ser_str=="{1:'one',2:'two'}");
}
[Test]
public void TestBytes()
{
Serializer serpent = new Serializer(indent: true);
byte[] bytes = new byte[] { 97, 98, 99, 100, 101, 102 }; // abcdef
byte[] ser = serpent.Serialize(bytes);
Assert.AreEqual("{\n 'data': 'YWJjZGVm',\n 'encoding': 'base64'\n}", S(strip_header(ser)));
Parser p = new Parser();
string parsed = p.Parse(ser).Root.ToString();
Assert.AreEqual(39, parsed.Length);
var hashtable = new Hashtable {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
byte[] bytes2 = Parser.ToBytes(hashtable);
Assert.AreEqual(bytes, bytes2);
var dict = new Dictionary {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
bytes2 = Parser.ToBytes(dict);
Assert.AreEqual(bytes, bytes2);
var dict2 = new Dictionary {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
bytes2 = Parser.ToBytes(dict2);
Assert.AreEqual(bytes, bytes2);
dict["encoding"] = "base99";
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
dict["data"] = "YWJjZGVm";
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
dict["encoding"] = "base64";
Assert.Throws(()=>Parser.ToBytes(dict));
Assert.Throws(()=>Parser.ToBytes(12345));
Assert.Throws(()=>Parser.ToBytes(null));
}
[Test]
public void TestCollection()
{
ICollection intlist = new LinkedList();
intlist.Add(42);
intlist.Add(43);
Serializer serpent = new Serializer();
byte[] ser = serpent.Serialize(intlist);
ser = strip_header(ser);
Assert.AreEqual("[42,43]", S(ser));
ser=strip_header(serpent.Serialize(new int[] {42}));
Assert.AreEqual("(42,)", S(ser));
ser=strip_header(serpent.Serialize(new int[] {42, 43}));
Assert.AreEqual("(42,43)", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(intlist));
Assert.AreEqual("[\n 42,\n 43\n]", S(ser));
ser=strip_header(serpent.Serialize(new int[] {42}));
Assert.AreEqual("(\n 42,\n)", S(ser));
ser=strip_header(serpent.Serialize(new int[] {42, 43}));
Assert.AreEqual("(\n 42,\n 43\n)", S(ser));
}
[Test]
public void TestIndentation()
{
var dict = new Dictionary();
var list = new List() {
1,
2,
new string[] {"a", "b"}
};
dict.Add("first", list);
dict.Add("second", new Dictionary {
{1, false}
});
dict.Add("third", new HashSet { 3, 4} );
Serializer serpent = new Serializer();
serpent.Indent=true;
byte[] ser = strip_header(serpent.Serialize(dict));
string txt=@"{
'first': [
1,
2,
(
'a',
'b'
)
],
'second': {
1: False
},
'third': {
3,
4
}
}";
// bit of trickery to deal with Windows/Unix line ending differences
txt = txt.Replace("\n","\r\n");
txt = txt.Replace("\r\r\n", "\r\n");
string ser_txt = S(ser);
ser_txt = ser_txt.Replace("\n", "\r\n");
ser_txt = ser_txt.Replace("\r\r\n", "\r\n");
Assert.AreEqual(txt, ser_txt);
}
[Test]
public void TestSorting()
{
Serializer serpent=new Serializer();
object data = new List { 3, 2, 1};
byte[] ser = strip_header(serpent.Serialize(data));
Assert.AreEqual("[3,2,1]", S(ser));
data = new int[] { 3,2,1 };
ser = strip_header(serpent.Serialize(data));
Assert.AreEqual("(3,2,1)", S(ser));
data = new HashSet {
42,
"hi"
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.IsTrue(S(ser)=="{\n 42,\n 'hi'\n}" || S(ser)=="{\n 'hi',\n 42\n}");
data = new Dictionary {
{5, "five"},
{3, "three"},
{1, "one"},
{4, "four"},
{2, "two"}
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.AreEqual("{\n 1: 'one',\n 2: 'two',\n 3: 'three',\n 4: 'four',\n 5: 'five'\n}", S(ser));
data = new HashSet {
"x",
"y",
"z",
"c",
"b",
"a"
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.AreEqual("{\n 'a',\n 'b',\n 'c',\n 'x',\n 'y',\n 'z'\n}", S(ser));
}
[Test]
public void TestClass()
{
Serializer.RegisterClass(typeof(SerializeTestClass), null);
Serializer serpent = new Serializer(indent: true);
var obj = new SerializeTestClass() {
i = 99,
s = "hi",
x = 42
};
byte[] ser = strip_header(serpent.Serialize(obj));
Assert.AreEqual("{\n '__class__': 'SerializeTestClass',\n 'i': 99,\n 'obj': None,\n 's': 'hi'\n}", S(ser));
}
[Test]
public void TestClass2()
{
Serializer.RegisterClass(typeof(SerializeTestClass), null);
Serializer serpent = new Serializer(indent: true, namespaceInClassName: true);
object obj = new SerializeTestClass() {
i = 99,
s = "hi",
x = 42
};
byte[] ser = strip_header(serpent.Serialize(obj));
Assert.AreEqual("{\n '__class__': 'Razorvine.Serpent.Test.SerializeTestClass',\n 'i': 99,\n 'obj': None,\n 's': 'hi'\n}", S(ser));
}
protected IDictionary testclassConverter(object obj)
{
SerializeTestClass o = (SerializeTestClass) obj;
IDictionary result = new Hashtable();
result["__class@__"] = o.GetType().Name+"@";
result["i@"] = o.i;
result["s@"] = o.s;
result["x@"] = o.x;
return result;
}
[Test]
public void TestCustomClassDict()
{
Serializer.RegisterClass(typeof(SerializeTestClass), testclassConverter);
Serializer serpent = new Serializer(indent: true);
var obj = new SerializeTestClass() {
i = 99,
s = "hi",
x = 42
};
byte[] ser = strip_header(serpent.Serialize(obj));
Assert.AreEqual("{\n '__class@__': 'SerializeTestClass@',\n 'i@': 99,\n 's@': 'hi',\n 'x@': 42\n}", S(ser));
}
[Test]
public void TestStruct()
{
Serializer serpent = new Serializer(indent: true);
var obj2 = new SerializeTestStruct() {
i = 99,
s = "hi",
x = 42
};
byte[] ser = strip_header(serpent.Serialize(obj2));
Assert.AreEqual("{\n '__class__': 'SerializeTestStruct',\n 'i': 99,\n 's': 'hi'\n}", S(ser));
}
[Test]
public void TestStruct2()
{
Serializer serpent = new Serializer(indent: true, namespaceInClassName: true);
var obj2 = new SerializeTestStruct() {
i = 99,
s = "hi",
x = 42
};
byte[] ser = strip_header(serpent.Serialize(obj2));
Assert.AreEqual("{\n '__class__': 'Razorvine.Serpent.Test.SerializeTestStruct',\n 'i': 99,\n 's': 'hi'\n}", S(ser));
}
[Test]
public void TestAnonymousClass()
{
Serializer serpent = new Serializer(indent: true);
Object obj = new {
Name="Harry",
Age=33,
Country="NL"
};
byte[] ser = strip_header(serpent.Serialize(obj));
Assert.AreEqual("{\n 'Age': 33,\n 'Country': 'NL',\n 'Name': 'Harry'\n}", S(ser));
}
[Test]
public void TestDateTime()
{
Serializer serpent = new Serializer();
DateTime date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Local);
byte[] ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Utc);
ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Unspecified);
ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45);
ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-01-20T23:59:45'", S(ser));
TimeSpan timespan = new TimeSpan(1, 10, 20, 30, 999);
ser = strip_header(serpent.Serialize(timespan));
Assert.AreEqual("123630.999", S(ser));
}
[Test]
public void TestDateTimeOffset()
{
Serializer serpent = new Serializer();
DateTimeOffset date = new DateTimeOffset(2013, 1, 20, 23, 59, 45, 999, TimeSpan.FromHours(+2));
byte[] ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-01-20T23:59:45.999+02:00'", S(ser));
date = new DateTimeOffset(2013, 5, 10, 13, 59, 45, TimeSpan.FromHours(+2));
ser = strip_header(serpent.Serialize(date));
Assert.AreEqual("'2013-05-10T13:59:45+02:00'", S(ser));
}
[Test]
public void TestException()
{
Exception x = new ApplicationException("errormessage");
Serializer serpent = new Serializer(indent:true);
byte[] ser = strip_header(serpent.Serialize(x));
Assert.AreEqual("{\n '__class__': 'ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
x.Data["custom_attribute"]=999;
ser = strip_header(serpent.Serialize(x));
Assert.AreEqual("{\n '__class__': 'ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {\n 'custom_attribute': 999\n }\n}", S(ser));
}
[Test]
public void TestExceptionWithNamespace()
{
Exception x = new ApplicationException("errormessage");
Serializer serpent = new Serializer(indent:true, namespaceInClassName: true);
byte[] ser = strip_header(serpent.Serialize(x));
Assert.AreEqual("{\n '__class__': 'System.ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
}
enum FooType {
Foobar,
Jarjar
}
[Test]
public void TestEnum()
{
FooType e = FooType.Jarjar;
Serializer serpent = new Serializer();
byte[] ser = strip_header(serpent.Serialize(e));
Assert.AreEqual("'Jarjar'", S(ser));
}
interface IBaseInterface {};
interface ISubInterface : IBaseInterface {};
class BaseClassWithInterface : IBaseInterface {};
class SubClassWithInterface : BaseClassWithInterface, ISubInterface {};
class BaseClass {};
class SubClass : BaseClass {};
abstract class AbstractBaseClass {};
class ConcreteSubClass : AbstractBaseClass {};
protected IDictionary AnyClassSerializer(object arg)
{
IDictionary result = new Hashtable();
result["(SUB)CLASS"] = arg.GetType().Name;
return result;
}
[Test]
public void testAbstractBaseClassHierarchyPickler()
{
ConcreteSubClass c = new ConcreteSubClass();
Serializer serpent = new Serializer();
serpent.Serialize(c);
Serializer.RegisterClass(typeof(AbstractBaseClass), AnyClassSerializer);
byte[] data = serpent.Serialize(c);
Assert.AreEqual("{'(SUB)CLASS':'ConcreteSubClass'}", S(strip_header(data)));
}
[Test]
public void TestInterfaceHierarchyPickler()
{
BaseClassWithInterface b = new BaseClassWithInterface();
SubClassWithInterface sub = new SubClassWithInterface();
Serializer serpent = new Serializer();
serpent.Serialize(b);
serpent.Serialize(sub);
Serializer.RegisterClass(typeof(IBaseInterface), AnyClassSerializer);
byte[] data = serpent.Serialize(b);
Assert.AreEqual("{'(SUB)CLASS':'BaseClassWithInterface'}", S(strip_header(data)));
data = serpent.Serialize(sub);
Assert.AreEqual("{'(SUB)CLASS':'SubClassWithInterface'}", S(strip_header(data)));
}
}
public class SerializeTestClass
{
public int x;
public string s {get; set;}
public int i {get; set;}
public object obj {get; set;}
}
public struct SerializeTestStruct
{
public int x;
public string s {get; set;}
public int i {get; set;}
}
}
Serpent-serpent-1.23/dotnet/Serpent.Test/Serpent.Test.csproj 0000664 0000000 0000000 00000006610 13126526344 0024161 0 ustar 00root root 0000000 0000000
{44F33161-24F6-41AC-8097-0AF7B43F3786}
Debug
x86
Library
Razorvine.Serpent.Test
Razorvine.Serpent.Test
Properties
OnBuildSuccess
False
False
4
false
8.0.30703
2.0
v4.5
x86
bin\Debug\
true
Full
False
True
DEBUG;TRACE
bin\Release\
false
PdbOnly
True
False
TRACE
AnyCPU
False
Auto
4194304
4096
none
none
..\lib\nunit.framework.dll
Always
{5A8E1B96-8C48-4A35-A3C4-0844486B2D47}
Serpent
Serpent-serpent-1.23/dotnet/Serpent.Test/SlowPerformanceTest.cs 0000664 0000000 0000000 00000003100 13126526344 0024665 0 ustar 00root root 0000000 0000000 using System;
using NUnit.Framework;
namespace Razorvine.Serpent.Test
{
[TestFixture]
public class SlowPerformanceTest {
// tests some performance regressions when they occur
[Test]
[Ignore("number parse performance in long lists has been resolved")]
public void TestManyFloats()
{
const int amount = 200000;
double[] array = new double[amount];
for(int i=0; i