public static ISTU NewInstance(Stream stream, uint owVersion, Type type = null)
{
if (stream == null)
{
return(null);
}
long pos = stream.Position;
using (BinaryReader reader = new BinaryReader(stream, Encoding.Default, true)) {
if (type != null)
{
return((ISTU)Activator.CreateInstance(type, stream, owVersion));
// return new Impl.Version2HashComparer.Version2Comparer(stream, owVersion); // for debug
// return new Impl.Version2HashComparer.MapComparer(stream, owVersion); // for debug
}
if (Version1.IsValidVersion(reader))
{
stream.Position = pos;
return(new Version1(stream, owVersion));
}
if (Version2.IsValidVersion(reader))
{
stream.Position = pos;
return(new Version2(stream, owVersion));
}
throw new InvalidDataException("Data stream is not a STU file");
}
}
public void RemoveFactWithoutVersionTestCase()
{
var version1 = new Version1();
var version2 = new Version2();
var factResult1 = new FactResult(0).SetVersionParam(version1);
var factResult2 = new FactResult(0).SetVersionParam(version2);
var factResultWithoutVersion = new FactResult(0);
GivenCreateContainer()
.And("Added versioned fact.", container =>
{
container.Add(factResult1);
container.Add(factResult2);
container.Add(factResultWithoutVersion);
})
.When("Try get fact.", container =>
container.Remove <FactResult>())
.Then("Check result.", container =>
{
foreach (var fact in container)
{
Assert.AreNotEqual(factResultWithoutVersion, fact, "Fact without version not removed.");
}
})
.Run();
}
void WriteCompressedHeader(BinaryWriter writer)
{
writer.Write(NextUnitId);
float version2 = Single.Parse(Version2.ToString(2));
writer.Write(version2);
}
public static bool CompareVersions(string V1, string V2)
{
List <int> Version1;
List <int> Version2;
try
{
Version1 = V1.Replace("V", "").Split('.').Select(x => Convert.ToInt32(x)).ToList();
Version2 = V2.Replace("V", "").Split('.').Select(x => Convert.ToInt32(x)).ToList();
}
catch { return(false); }
for (var i = 0; i < Version1.Count(); i++)
{
if (i >= Version2.Count())
{
Version2.Add(0);
}
if (Version1[i] > Version2[i])
{
return(true);
}
if (Version1[i] < Version2[i])
{
return(false);
}
}
return(false);
}
public void Version2SignatureVerificationInvalidPublicKeyFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <ArgumentException>(() => paseto.Verify(TokenV2, new byte[16]));
}
public void Version2SignatureVerificationInvalidTokenHeaderFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <NotSupportedException>(() => paseto.Verify("v2.remote.", new byte[32]));
}
public void Version2SignatureVerificationNullPublicKeyFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <ArgumentNullException>(() => paseto.Verify(TokenV2, null));
}
public void Version2SignatureEmptySecretFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <ArgumentException>(() => paseto.Sign(new byte[0], HelloPaseto));
}
public void Version2SignatureVerificationEmptyTokenFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <ArgumentNullException>(() => paseto.Verify(string.Empty, null));
}
public void Version2SignatureNullSecretFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <ArgumentNullException>(() => paseto.Sign(null, HelloPaseto));
}
public void Version2SignatureVerificationInvalidTokenBodyFails()
{
// Arrange
var paseto = new Version2();
// Act & Assert
Assert.Throws <NotSupportedException>(() => paseto.Verify("v2.public.eyJleGFtcGxlIjoiSGVsbG8gUGFzZX", new byte[32]));
}
public void Versioning()
{
var v1 = new Version1
{
MyProperty1 = 100,
MyProperty2 = 200,
MyProperty3 = 300
};
var v2 = new Version2
{
MyProperty1 = 100,
MyProperty2 = 200,
MyProperty3 = 300,
MyProperty5 = 500,
};
var v0 = new Version0
{
MyProperty1 = 100,
};
var v1Bytes = MessagePackSerializer.Serialize(v1);
var v2Bytes = MessagePackSerializer.Serialize(v2);
var v0Bytes = MessagePackSerializer.Serialize(v0);
var a = MessagePackSerializer.Deserialize <Version1>(v1Bytes);
a.MyProperty1.Is(100);
a.MyProperty2.Is(200);
a.MyProperty3.Is(300);
var b = MessagePackSerializer.Deserialize <Version2>(v2Bytes);
b.MyProperty1.Is(100);
b.MyProperty2.Is(200);
b.MyProperty3.Is(300);
b.MyProperty5.Is(500);
var c = MessagePackSerializer.Deserialize <Version0>(v0Bytes);
c.MyProperty1.Is(100);
// smaller than schema
var v2_ = MessagePackSerializer.Deserialize <Version2>(v1Bytes);
v2_.MyProperty1.Is(v1.MyProperty1);
v2_.MyProperty2.Is(v1.MyProperty2);
v2_.MyProperty3.Is(v1.MyProperty3);
v2_.MyProperty5.Is(0);
// larger than schema
var v0_ = MessagePackSerializer.Deserialize <Version0>(v1Bytes);
v0_.MyProperty1.Is(v1.MyProperty1);
}
public void Version2SignatureEmptyPayloadFails()
{
// Arrange
var paseto = new Version2();
Ed25519.KeyPairFromSeed(out var pk, out var sk, new byte[32]);
// Act & Assert
Assert.Throws <ArgumentNullException>(() => paseto.Sign(sk, string.Empty));
}
public static T[] GetAllInstances <T>(ulong key) where T : STUInstance
{
ISTU stu = OpenSTUSafe(key);
Version2 ver2 = stu as Version2;
if (ver2 == null)
{
return(null);
}
return(stu?.Instances.Concat(ver2.HiddenInstances).OfType <T>().ToArray() ?? new T[0]);
}
public static void Main()
{
Int32 version = 3;
switch (version)
{
case 1: Version1.Go(); break;
case 2: Version2.Go(); break;
case 3: Version3.Go(); break;
}
}
public void Version2SignatureTest()
{
// Arrange
var paseto = new Version2();
var seed = new byte[32];
Ed25519.KeyPairFromSeed(out var pk, out var sk, seed);
// Act
var signature = paseto.Sign(sk, HelloPaseto);
// Assert
Assert.IsNotNull(signature);
}
public void Versioning()
{
var v1 = new Version1
{
MyProperty1 = 100,
MyProperty2 = 200,
MyProperty3 = 300
};
var v2 = new Version2
{
MyProperty1 = 100,
MyProperty2 = 200,
MyProperty3 = 300,
MyProperty5 = 500,
};
var v0 = new Version0
{
MyProperty1 = 100,
};
var v1Bytes = serializer.Serialize(v1);
var v2Bytes = serializer.Serialize(v2);
var v0Bytes = serializer.Serialize(v0);
var a = serializer.ToJson(v1Bytes);
var b = serializer.ToJson(v2Bytes);
var c = serializer.ToJson(v0Bytes);
serializer.Deserialize <Version1>(v1Bytes).IsNotStructuralEqual(v1Bytes);
serializer.Deserialize <Version2>(v2Bytes).IsNotStructuralEqual(v2Bytes);
serializer.Deserialize <Version0>(v0Bytes).IsNotStructuralEqual(v0Bytes);
// smaller than schema
var v2_ = serializer.Deserialize <Version2>(v1Bytes);
v2_.MyProperty1.Is(v1.MyProperty1);
v2_.MyProperty2.Is(v1.MyProperty2);
v2_.MyProperty3.Is(v1.MyProperty3);
v2_.MyProperty5.Is(0);
// larger than schema
var v0_ = serializer.Deserialize <Version0>(v1Bytes);
v0_.MyProperty1.Is(v1.MyProperty1);
}
public void Version2SignatureVerificationTest()
{
// Arrange
var paseto = new Version2();
var seed = new byte[32];
RandomNumberGenerator.Create().GetBytes(seed);
Ed25519.KeyPairFromSeed(out var pk, out var sk, seed);
//var pub = Convert.ToBase64String(pk);
// Act
var token = paseto.Sign(sk, HelloPaseto);
var verified = paseto.Verify(token, pk).Valid;
// Assert
Assert.IsTrue(verified);
}
internal static Dataspace Read(
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < DSHeader.Size)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
DSHeader
fHeader = DSHeader.Read(aReader);
long
fMessageBodySize;
Dataspace
fToRetrun;
long?
fBodySize = aLocalMessageSize.HasValue
? (long?)aLocalMessageSize.Value - DSHeader.Size
: null;
switch (fHeader.Version)
{
case 1:
fToRetrun = Version1.ReadAfterHeader(
fHeader,
aReader,
fBodySize,
out fMessageBodySize);
break;
case 2:
fToRetrun = Version2.ReadAfterHeader(
fHeader,
aReader,
fBodySize,
out fMessageBodySize);
break;
default:
throw new UnknownMessageVersion <Dataspace>(fHeader.Version);
}
aBytes = DSHeader.Size + fMessageBodySize;
return(fToRetrun);
}
public static void DumpSTUFull(Version2 stu, CASCHandler handler, Dictionary <ulong, Record> map,
string instanceWildcard = null)
{
// tries to properly dump an STU to the console
// uses handler to load GUIDs, and process the types
// colour support doesn't work as well as I had hoped, because Windows is bad.
// after setitting the colour 16 times it breaks, so I have to reset the colours every time
// this means that any past-written colours will change.
if (stu == null)
{
return;
}
STUDebugger debugger = new STUDebugger(handler, map);
debugger.DumpSTU(stu, instanceWildcard);
}
public void GetFactWithoutVersionTestCase()
{
var version1 = new Version1();
var version2 = new Version2();
var factResult1 = new FactResult(0).SetVersionParam(version1);
var factResult2 = new FactResult(0).SetVersionParam(version2);
var factResultWithoutVersion = new FactResult(0);
GivenCreateContainer()
.And("Added versioned fact.", container =>
{
container.Add(factResult1);
container.Add(factResult2);
container.Add(factResultWithoutVersion);
})
.When("Try get fact.", container => container.GetFact <FactResult>())
.ThenAreEqual(factResultWithoutVersion)
.Run();
}
public void VersiongCheckReadme()
{
var v1 = new Version1 {
Prop1 = 999, Prop2 = 1000
};
var v2 = new Version2 {
Prop1 = 10, Prop2 = 100, NewType = 9
};
var v1Data = ZeroFormatterSerializer.Serialize(v1);
var v2Data = ZeroFormatterSerializer.Serialize(v2);
// deserialize new data to old schema
var newV1 = ZeroFormatterSerializer.Deserialize <Version1>(v2Data);
newV1.Prop1.Is(10); newV1.Prop2.Is(100);
var newV2 = ZeroFormatterSerializer.Deserialize <Version2>(v1Data);
newV2.Prop1.Is(999); newV2.Prop2.Is(1000); newV2.NewType.Is(default(int));
newV2.NewType = 99999;
ZeroFormatterSerializer.Convert(newV2).NewType.Is(99999);
}
public static string Convert(string s)
{
Version2 v2 = JsonConvert.DeserializeObject <Version2>(s);
Dictionary <string, double> cst = new Dictionary <string, double>();
if (v2.constants != null)
{
foreach (var x in v2.constants)
{
cst.Add(x.Key, x.Value);
}
}
List <NewItem> items = new List <NewItem>();
foreach (var x in v2.products)
{
double d;
string ss = x.Value.price;
if (v2.constants != null)
{
foreach (var c in cst)
{
ss = ss.Replace(c.Key, c.Value.ToString());
}
ss = ss.Replace(",", ".");
}
Double.TryParse(new DataTable().Compute(ss, "").ToString(), out d);
items.Add(new NewItem(x.Key, x.Value.name, d, x.Value.count));
}
Version3 v3 = new Version3("3", items);
string res = JsonConvert.SerializeObject(v3, Formatting.Indented);
res = res.Replace(".0,", ",");
res = res.Replace(" ", " ");
return(res);
}
public override int GetHashCode()
{
return(Version1.GetHashCode() * 13 + Version2.GetHashCode() * 17 + Version3.GetHashCode() * 19 + Version4.GetHashCode() * 23);
}
internal static bool TestCase()
{
#region 序列化版本 0 的数据，手动传 SerializeConfig 参数仅用于测试模拟历史数据版本
byte[] data0 = AutoCSer.BinarySerialize.Serializer.Serialize(new GlobalVersion {
Value9 = 1
}, new AutoCSer.BinarySerialize.SerializeConfig {
GlobalVersion = 0
});
Version1 value1 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version1>(data0);
if (value1 == null || value1.Value9 != 1)
{
return(false);
}
Version2 value2 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version2>(data0);
if (value2 == null || value2.Value9 != 1)
{
return(false);
}
Version3 value3 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version3>(data0);
if (value3 == null || value3.Value9 != 1)
{
return(false);
}
#endregion
#region 序列化版本 1 的数据，手动传 SerializeConfig 参数仅用于测试模拟历史数据版本
byte[] data1 = AutoCSer.BinarySerialize.Serializer.Serialize(new Version1 {
Value9 = 1, Value8 = 2
}, new AutoCSer.BinarySerialize.SerializeConfig {
GlobalVersion = 1
});
value1 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version1>(data1);
if (value1 == null || value1.Value9 != 1 || value1.Value8 != 2)
{
return(false);
}
value2 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version2>(data1);
if (value2 == null || value2.Value9 != 1 || value2.Value8 != 2)
{
return(false);
}
value3 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version3>(data1);
if (value3 == null || value3.Value9 != 1 || value3.Value8 != 2)
{
return(false);
}
#endregion
#region 序列化版本 2 的数据，手动传 SerializeConfig 参数仅用于测试模拟历史数据版本
byte[] data2 = AutoCSer.BinarySerialize.Serializer.Serialize(new Version2 {
Value9 = 1, Value8 = 2, Value7 = 3
}, new AutoCSer.BinarySerialize.SerializeConfig {
GlobalVersion = 2
});
value2 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version2>(data2);
if (value2 == null || value2.Value9 != 1 || value2.Value8 != 0 || value2.Value7 != 3)
{
return(false);
}
value3 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version3>(data2);
if (value3 == null || value3.Value9 != 1 || value3.Value8 != 0)
{
return(false);
}
#endregion
#region 序列化版本 3 的数据，手动传 SerializeConfig 参数仅用于测试模拟历史数据版本
byte[] data3 = AutoCSer.BinarySerialize.Serializer.Serialize(new Version3 {
Value9 = 1, Value8 = 2, Value6 = 4
}, new AutoCSer.BinarySerialize.SerializeConfig {
GlobalVersion = 3
});
value3 = AutoCSer.BinarySerialize.DeSerializer.DeSerialize <Version3>(data3);
if (value3 == null || value3.Value9 != 1 || value3.Value8 != 0 || value3.Value6 != 4)
{
return(false);
}
#endregion
return(true);
}
static async Task Second()
{
Version2 version2 = new Version2();
}
