public static TheoryData <string> InvalidCookieNames() { var invalidNames = new TheoryData <string> { "foo=", "foo;", "foo\0", "foo👍", "foo\\", "foo(", "foo)", "foo<", "foo>", "foo@foo", "foo,bar", "foo:bar", "foo\"bar", "bar/foo", "foo[bar", "foo]bar", "foo?bar", "{foo", "}foo", }; foreach (var value in Constant.WhitespaceValues) { invalidNames.Add(value); } return(invalidNames); }
public static TheoryData <string, string, string, string> TestData() { var testsString = EmbeddedResourceUtils.LoadResourceFile(typeof(JsonPatchFactoryTests).Assembly, "JsonPatchGenerator.Tests.Resources.tests.json"); var tests = (JArray)JToken.Parse(testsString); var result = new TheoryData <string, string, string, string>(); foreach (var test in tests.Cast <JObject>()) { if (test.Property("error") != null) { continue; } if (test.Property("disabled") != null) { continue; } var doc = test.Property("doc") !.Value; var expected = test.Property("expected") !.Value; var patch = test.Property("patch") !.Value; var comment = test.Property("comment")?.Value.Value <string>() ?? string.Empty; result.Add(doc.ToString(Formatting.None), expected.ToString(Formatting.None), patch.ToString(Formatting.None), comment); } return(result); }
private static TheoryData <TestCase> GetTestMethodsFromDll(Func <string[], MethodDefinitionHandle, TestCase> methodSelector) { var retVal = new TheoryData <TestCase>(); foreach (var testDllName in GetAllTestDlls()) { var testModule = GetModuleForTestAssembly(testDllName); foreach (var methodHandle in testModule.MetadataReader.MethodDefinitions) { var method = (EcmaMethod)testModule.GetMethod(methodHandle); var methodName = method.Name; if (!String.IsNullOrEmpty(methodName) && methodName.Contains("_")) { var mparams = methodName.Split('_'); var specialMethodHandle = HandleSpecialTests(mparams, method); var newItem = methodSelector(mparams, specialMethodHandle); if (newItem != null) { newItem.TestName = mparams[0]; newItem.MethodName = methodName; newItem.ModuleName = testDllName; retVal.Add(newItem); } } } } return(retVal); }
// helper method to generate theory data from all values of an enum type internal static TheoryData<T> GetEnumTheoryData<T>() where T : Enum { var data = new TheoryData<T>(); foreach (T item in Enum.GetValues(typeof(T))) data.Add(item); return data; }
public static TheoryData <DistributedCacheEntryOptions> PresetOptions() { var theoryData = new TheoryData <DistributedCacheEntryOptions>(); theoryData.Add(new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30) }); theoryData.Add(new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromMinutes(30) }); theoryData.Add(new DistributedCacheEntryOptions { AbsoluteExpiration = DateTimeOffset.Now.AddDays(1) }); return(theoryData); }
private static TheoryData <string, int, int> GenerateImageResizeData() { var result = new TheoryData <string, int, int>(); string[] resamplerNames = typeof(KnownResamplers).GetProperties(BindingFlags.Public | BindingFlags.Static) .Select(p => p.Name) .Where(name => name != nameof(KnownResamplers.NearestNeighbor)) .ToArray(); int[] dimensionVals = { // Arbitrary, small dimensions: 9, 10, 11, 13, 49, 50, 53, 99, 100, 199, 200, 201, 299, 300, 301, // Typical image sizes: 640, 480, 800, 600, 1024, 768, 1280, 960, 1536, 1180, 1600, 1200, 2048, 1536, 2240, 1680, 2560, 1920, 3032, 2008, 3072, 2304, 3264, 2448 }; IOrderedEnumerable <(int s, int d)> source2Dest = dimensionVals .SelectMany(s => dimensionVals.Select(d => (s, d))) .OrderBy(x => x.s + x.d); foreach (string resampler in resamplerNames) { foreach ((int s, int d)x in source2Dest) { result.Add(resampler, x.s, x.d); } } return(result); }
public static TheoryData <INode[], IEdge[], IPath[]> SelfReferingNodes() { var data = new TheoryData <INode[], IEdge[], IPath[]>(); var nStart = new Node("nStart", new List <string> { "e1" }, new List <string> { "e1", "e2" }); var n1 = new Node("n1", new List <string> { "e2", "e3" }, new List <string> { "e3", "e4" }); var nEnd = new Node("nEnd", new List <string> { "e4" }); var e1 = new Edge("e1", "nStart", "nStart"); var e2 = new Edge("e2", "nStart", "n1"); var e3 = new Edge("e3", "n1", "n1"); var e4 = new Edge("e4", "n1", "nEnd"); data.Add( new INode[] { nStart, n1, nEnd }, new IEdge[] { e1, e2, e3, e4 }, new IPath[] { new Path(new IGraphObject[] { nStart, e2, n1, e4, nEnd }) } ); return(data); }
public static TheoryData <ScanCompareType, float, float, byte[], ScanResult, bool, ScanResult> GetTestCompareWithPreviousData() { var data = new TheoryData <ScanCompareType, float, float, byte[], ScanResult, bool, ScanResult> { { ScanCompareType.Changed, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), true, new FloatScanResult(0.0f) }, { ScanCompareType.Changed, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.NotChanged, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), true, new FloatScanResult(1.0f) }, { ScanCompareType.NotChanged, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.Increased, 0.0f, 0.0f, BitConverter.GetBytes(2.0f), new FloatScanResult(1.0f), true, new FloatScanResult(2.0f) }, { ScanCompareType.Increased, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.Increased, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.IncreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(2.0f), new FloatScanResult(1.0f), true, new FloatScanResult(2.0f) }, { ScanCompareType.IncreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), true, new FloatScanResult(1.0f) }, { ScanCompareType.IncreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.Decreased, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), true, new FloatScanResult(0.0f) }, { ScanCompareType.Decreased, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.Decreased, 0.0f, 0.0f, BitConverter.GetBytes(2.0f), new FloatScanResult(1.0f), false, null }, { ScanCompareType.DecreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(0.0f), new FloatScanResult(1.0f), true, new FloatScanResult(0.0f) }, { ScanCompareType.DecreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(1.0f), new FloatScanResult(1.0f), true, new FloatScanResult(1.0f) }, { ScanCompareType.DecreasedOrEqual, 0.0f, 0.0f, BitConverter.GetBytes(2.0f), new FloatScanResult(1.0f), false, null } }; var basicData = GetTestCompareBasicData(); foreach (var x in basicData) { data.Add((ScanCompareType)x[0], (float)x[1], (float)x[2], (byte[])x[3], new FloatScanResult(1.0f), (bool)x[4], (ScanResult)x[5]); } return(data); }
public static TheoryData <Enum> GetEnumTypeTheoryDataInvalidMasked(Type enumType) { var data = new TheoryData <Enum>(); IEnumerable <Enum> values = Enum.GetValues(enumType).Cast <Enum>().OrderBy(p => p); long allMasked = 0; foreach (Enum value in values) { allMasked |= Convert.ToInt64(value); } data.Add((Enum)Enum.ToObject(enumType, int.MaxValue)); data.Add((Enum)Enum.ToObject(enumType, allMasked + 1)); return(data); }
public static TheoryData <string, IReadOnlyList <SubtitleTrackEvent> > Parse_MultipleDialogues_TestData() { var data = new TheoryData <string, IReadOnlyList <SubtitleTrackEvent> >(); data.Add( @"[Events] Format: Layer, Start, End, Text Dialogue: ,0:00:01.18,0:00:01.85,dialogue1 Dialogue: ,0:00:02.18,0:00:02.85,dialogue2 Dialogue: ,0:00:03.18,0:00:03.85,dialogue3 ", new List <SubtitleTrackEvent> { new SubtitleTrackEvent("1", "dialogue1") { StartPositionTicks = 11800000, EndPositionTicks = 18500000 }, new SubtitleTrackEvent("2", "dialogue2") { StartPositionTicks = 21800000, EndPositionTicks = 28500000 }, new SubtitleTrackEvent("3", "dialogue3") { StartPositionTicks = 31800000, EndPositionTicks = 38500000 } }); return(data); }
private static TheoryData <TestCase> GetTestTypeFromDll(Func <string[], TypeDefinitionHandle, TestCase> typeSelector) { var retVal = new TheoryData <TestCase>(); foreach (var testDllName in GetAllTestDlls()) { EcmaModule testModule = GetModuleForTestAssembly(testDllName); MetadataReader metadataReader = testModule.PEReader.GetMetadataReader(); foreach (TypeDefinitionHandle typeHandle in metadataReader.TypeDefinitions) { var typeDef = metadataReader.GetTypeDefinition(typeHandle); var typeName = metadataReader.GetString(typeDef.Name); if (!string.IsNullOrEmpty(typeName) && typeName.Contains("_")) { var mparams = typeName.Split('_'); TestCase newItem = typeSelector(mparams, typeHandle); if (newItem != null) { newItem.TestName = mparams[0]; newItem.TypeName = typeName; newItem.ModuleName = testDllName; retVal.Add(newItem); } } } } return(retVal); }
public static TheoryData <INode[], IEdge[], IPath[]> ShorterPath() { var data = new TheoryData <INode[], IEdge[], IPath[]>(); var nStart = new Node("nStart", null, new List <string> { "e1", "e3" }); var n2 = new Node("n2", new List <string> { "e1" }, new List <string> { "e2" }); var nEnd = new Node("nEnd", new List <string> { "e2", "e3" }); var e1 = new Edge("e1", "nStart", "n2"); var e2 = new Edge("e2", "n2", "nEnd"); var e3 = new Edge("e3", "nStart", "nEnd"); data.Add( new INode[] { nStart, n2, nEnd }, new IEdge[] { e1, e2, e3 }, new IPath[] { new Path(new IGraphObject[] { nStart, e3, nEnd }) }); return(data); }
// helper method to generate theory data for some values of a int internal static TheoryData <float> GetFloatTheoryData() { var data = new TheoryData <float>(); data.Add(float.MaxValue); data.Add(float.MinValue); data.Add(float.Epsilon); data.Add(float.Epsilon * -1); data.Add(float.NegativeInfinity); // not sure about these two data.Add(float.PositiveInfinity); // 2 data.Add(0); data.Add(-1); data.Add(1); data.Add(float.MaxValue / 2); return(data); }
public static IEnumerable <object[]> Serialize_should_throw_when_effectiveGuidRepresentation_is_Unspecified_MemberData() { var data = new TheoryData <GuidRepresentationMode, GuidRepresentation, GuidRepresentation, GuidRepresentation?>(); foreach (var defaultGuidRepresentationMode in EnumHelper.GetValues <GuidRepresentationMode>()) { foreach (var defaultGuidRepresentation in EnumHelper.GetValues <GuidRepresentation>()) { if (defaultGuidRepresentationMode == GuidRepresentationMode.V3 && defaultGuidRepresentation != GuidRepresentation.Unspecified) { continue; } foreach (var serializerGuidRepresentation in EnumHelper.GetValues <GuidRepresentation>()) { foreach (var writerGuidRepresentation in EnumHelper.GetValuesAndNull <GuidRepresentation>()) { var effectiveGuidRepresentation = serializerGuidRepresentation; if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && serializerGuidRepresentation == GuidRepresentation.Unspecified) { effectiveGuidRepresentation = writerGuidRepresentation ?? defaultGuidRepresentation; } if (effectiveGuidRepresentation != GuidRepresentation.Unspecified) { continue; } data.Add(defaultGuidRepresentationMode, defaultGuidRepresentation, serializerGuidRepresentation, writerGuidRepresentation); } } } } return(data); }
private static void AddDecryptMismatchTheoryData( string testId, SymmetricSecurityKey decryptKey, SymmetricSecurityKey encryptkey, string decryptAlgorithm, string encryptAlgorithm, ExpectedException ee, TheoryData <AuthenticatedEncryptionTestParams> theoryData) { var authenticatedData = Guid.NewGuid().ToByteArray(); var plainText = Guid.NewGuid().ToByteArray(); var provider = new AuthenticatedEncryptionProvider(encryptkey, encryptAlgorithm); var results = provider.Encrypt(plainText, authenticatedData); theoryData.Add(new AuthenticatedEncryptionTestParams { AuthenticatedData = authenticatedData, DecryptAlgorithm = decryptAlgorithm, DecryptKey = decryptKey, EE = ee, EncryptionResults = results, Provider = new AuthenticatedEncryptionProvider(decryptKey, decryptAlgorithm), TestId = testId }); }
public static TheoryData <ScanCompareType, byte, byte, byte[], ScanResult, bool, ScanResult> GetTestCompareWithPreviousData() { var data = new TheoryData <ScanCompareType, byte, byte, byte[], ScanResult, bool, ScanResult> { { ScanCompareType.Changed, 0, 0, new byte[] { 0 }, new ByteScanResult(1), true, new ByteScanResult(0) }, { ScanCompareType.Changed, 0, 0, new byte[] { 1 }, new ByteScanResult(1), false, null }, { ScanCompareType.NotChanged, 0, 0, new byte[] { 1 }, new ByteScanResult(1), true, new ByteScanResult(1) }, { ScanCompareType.NotChanged, 0, 0, new byte[] { 0 }, new ByteScanResult(1), false, null }, { ScanCompareType.Increased, 0, 0, new byte[] { 2 }, new ByteScanResult(1), true, new ByteScanResult(2) }, { ScanCompareType.Increased, 0, 0, new byte[] { 1 }, new ByteScanResult(1), false, null }, { ScanCompareType.Increased, 0, 0, new byte[] { 0 }, new ByteScanResult(1), false, null }, { ScanCompareType.IncreasedOrEqual, 0, 0, new byte[] { 2 }, new ByteScanResult(1), true, new ByteScanResult(2) }, { ScanCompareType.IncreasedOrEqual, 0, 0, new byte[] { 1 }, new ByteScanResult(1), true, new ByteScanResult(1) }, { ScanCompareType.IncreasedOrEqual, 0, 0, new byte[] { 0 }, new ByteScanResult(1), false, null }, { ScanCompareType.Decreased, 0, 0, new byte[] { 0 }, new ByteScanResult(1), true, new ByteScanResult(0) }, { ScanCompareType.Decreased, 0, 0, new byte[] { 1 }, new ByteScanResult(1), false, null }, { ScanCompareType.Decreased, 0, 0, new byte[] { 2 }, new ByteScanResult(1), false, null }, { ScanCompareType.DecreasedOrEqual, 0, 0, new byte[] { 0 }, new ByteScanResult(1), true, new ByteScanResult(0) }, { ScanCompareType.DecreasedOrEqual, 0, 0, new byte[] { 1 }, new ByteScanResult(1), true, new ByteScanResult(1) }, { ScanCompareType.DecreasedOrEqual, 0, 0, new byte[] { 2 }, new ByteScanResult(1), false, null } }; var basicData = GetTestCompareBasicData(); foreach (var x in basicData) { data.Add((ScanCompareType)x[0], (byte)x[1], (byte)x[2], (byte[])x[3], new ByteScanResult(1), (bool)x[4], (ScanResult)x[5]); } return(data); }
private static TheoryData <string, int, int> GenerateImageResizeData() { var result = new TheoryData <string, int, int>(); string[] resamplerNames = TestUtils.GetAllResamplerNames(false); int[] dimensionVals = { // Arbitrary, small dimensions: 9, 10, 11, 13, 49, 50, 53, 99, 100, 199, 200, 201, 299, 300, 301, // Typical image sizes: 640, 480, 800, 600, 1024, 768, 1280, 960, 1536, 1180, 1600, 1200, 2048, 1536, 2240, 1680, 2560, 1920, 3032, 2008, 3072, 2304, 3264, 2448 }; IOrderedEnumerable <(int s, int d)> source2Dest = dimensionVals .SelectMany(s => dimensionVals.Select(d => (s, d))) .OrderBy(x => x.s + x.d); foreach (string resampler in resamplerNames) { foreach ((int s, int d)x in source2Dest) { result.Add(resampler, x.s, x.d); } } return(result); }
public static TheoryData <Test> GetTestSuite(string @case, string[] excludedStrings) { var testsDirectory = Path.GetRelativePath(Directory.GetCurrentDirectory(), $"SCION.SCXML/tests/{@case}"); var excluded = excludedStrings.Select(data => { var splitted = data.Split(":", 2).ToArray(); return(name: splitted[0], reason: splitted[1]); }).ToDictionary(e => e.name, e => e.reason); if (!Directory.Exists(testsDirectory)) { throw new ArgumentException($"Could not find case: {@case} ({testsDirectory} does not exist)"); } var testConfigurations = Directory.GetFiles(testsDirectory, "*.scxml") .Select(Path.GetFileName) .Select(name => name.Replace(".scxml", string.Empty)) .Select(name => (name, path: Path.Join(testsDirectory, name))) .Select(test => new Test( test.name, $"{test.path}.scxml", File.ReadAllText($"{test.path}.json"), excluded.ContainsKey(test.name) ? Option.From(excluded[test.name]) : Option.None <string>())); var theoryData = new TheoryData <Test>(); foreach (var test in testConfigurations) { theoryData.Add(test); } return(theoryData); }
public static TheoryData <string, SecurityKey, bool> HasPrivateKeyTheoryData() { var theoryData = new TheoryData <string, SecurityKey, bool>(); #if NET452 || NET461 theoryData.Add( "KeyingMaterial.RsaSecurityKeyWithCspProvider_2048", KeyingMaterial.RsaSecurityKeyWithCspProvider_2048, true ); theoryData.Add( "KeyingMaterial.RsaSecurityKeyWithCspProvider_2048_Public", KeyingMaterial.RsaSecurityKeyWithCspProvider_2048_Public, false ); #endif #if NET461 theoryData.Add( "KeyingMaterial.RsaSecurityKeyWithCngProvider_2048", KeyingMaterial.RsaSecurityKeyWithCngProvider_2048, true ); theoryData.Add( "KeyingMaterial.RsaSecurityKeyWithCngProvider_2048_Public", KeyingMaterial.RsaSecurityKeyWithCngProvider_2048_Public, false ); #endif theoryData.Add( "KeyingMaterial.RsaSecurityKey_2048", KeyingMaterial.RsaSecurityKey_2048, true ); theoryData.Add( "KeyingMaterial.RsaSecurityKey_2048_Public", KeyingMaterial.RsaSecurityKey_2048_Public, false ); theoryData.Add( "KeyingMaterial.RsaSecurityKey_2048_FromRsa", KeyingMaterial.RsaSecurityKey_2048_FromRsa, true ); theoryData.Add( "KeyingMaterial.RsaSecurityKey_2048_FromRsa_Public", KeyingMaterial.RsaSecurityKey_2048_FromRsa_Public, false ); return(theoryData); }
public static TheoryData <IEnumerable <T> > EnumerableData() { var data = new TheoryData <IEnumerable <T> >(); IEnumerable <int> counts = CountData().Select(array => array[0]).Cast <int>(); foreach (int count in counts) { data.Add(Enumerable.Repeat(default(T), count)); // Test perf: Capture the items into a List here so we // only enumerate the sequence once. data.Add(s_generator.GenerateEnumerable(count).ToList()); } return(data); }
public static TheoryData <int> CapacityData() { var data = new TheoryData <int>(); for (int i = 0; i < 6; i++) { int powerOfTwo = 1 << i; // Return numbers of the form 2^N - 1, 2^N and 2^N + 1 // This should cover most of the interesting cases data.Add(powerOfTwo - 1); data.Add(powerOfTwo); data.Add(powerOfTwo + 1); } return(data); }
public static TheoryData <Size> GetSizeTheoryData(TestIncludeType includeType) { var data = new TheoryData <Size>(); if (!includeType.HasFlag(TestIncludeType.NoPositives)) { data.Add(new Size()); data.Add(new Size(new Point(1, 1))); data.Add(new Size(1, 2)); } if (!includeType.HasFlag(TestIncludeType.NoNegatives)) { data.Add(new Size(-1, 1)); data.Add(new Size(1, -1)); } return(data); }
public static TheoryData <AuthenticatedEncryptionTestParams> IsSupportedAlgorithmTheoryData() { var theoryData = new TheoryData <AuthenticatedEncryptionTestParams>(); theoryData.Add(new AuthenticatedEncryptionTestParams { DecryptAlgorithm = SecurityAlgorithms.Aes128CbcHmacSha256, DecryptKey = null, EE = ExpectedException.NoExceptionExpected, IsSupportedAlgorithm = false, Provider = new DerivedAuthenticatedEncryptionProvider(Default.SymmetricEncryptionKey256, SecurityAlgorithms.Aes128CbcHmacSha256), TestId = "Test1" }); theoryData.Add(new AuthenticatedEncryptionTestParams { DecryptAlgorithm = SecurityAlgorithms.Aes128CbcHmacSha256, DecryptKey = null, EE = ExpectedException.NoExceptionExpected, IsSupportedAlgorithm = false, Provider = new DerivedAuthenticatedEncryptionProvider(Default.SymmetricEncryptionKey256, SecurityAlgorithms.Aes128CbcHmacSha256), TestId = "Test2" }); theoryData.Add(new AuthenticatedEncryptionTestParams { DecryptAlgorithm = SecurityAlgorithms.Aes128Encryption, DecryptKey = Default.SymmetricEncryptionKey256, EE = ExpectedException.NoExceptionExpected, IsSupportedAlgorithm = false, Provider = new DerivedAuthenticatedEncryptionProvider(Default.SymmetricEncryptionKey256, SecurityAlgorithms.Aes128CbcHmacSha256), TestId = "Test3" }); theoryData.Add(new AuthenticatedEncryptionTestParams { DecryptAlgorithm = SecurityAlgorithms.Aes128CbcHmacSha256, DecryptKey = Default.AsymmetricSigningKey, EE = ExpectedException.NoExceptionExpected, IsSupportedAlgorithm = false, Provider = new DerivedAuthenticatedEncryptionProvider(Default.SymmetricEncryptionKey256, SecurityAlgorithms.Aes128CbcHmacSha256), TestId = "Test4" }); return(theoryData); }
public static TheoryData <Point> GetPointTheoryData(TestIncludeType includeType) { var data = new TheoryData <Point>(); if (!includeType.HasFlag(TestIncludeType.NoPositives)) { data.Add(new Point()); data.Add(new Point(10)); data.Add(new Point(1, 2)); } if (!includeType.HasFlag(TestIncludeType.NoNegatives)) { data.Add(new Point(int.MaxValue, int.MinValue)); data.Add(new Point(-1, -2)); } return(data); }
public static TheoryData GetEnumTypeTheoryData(Type enumType) { var data = new TheoryData<Enum>(); foreach (Enum item in Enum.GetValues(enumType)) { data.Add(item); } return data; }
private static TheoryData <string, Dictionary <string, string> > GetParts_ValidAuthHeader_Success_Data() { var data = new TheoryData <string, Dictionary <string, string> >(); data.Add( "x=\"123,123\",y=\"123\"", new Dictionary <string, string> { { "x", "123,123" }, { "y", "123" } }); data.Add( "x=\"123,123\", y=\"123\",z=\"'hi'\"", new Dictionary <string, string> { { "x", "123,123" }, { "y", "123" }, { "z", "'hi'" } }); data.Add( "x=\"ab\"", new Dictionary <string, string> { { "x", "ab" } }); data.Add( "param=Hörbücher", new Dictionary <string, string> { { "param", "Hörbücher" } }); data.Add( "param=%22%Hörbücher", new Dictionary <string, string> { { "param", "\"%Hörbücher" } }); return(data); }
public static TheoryData <string, SecurityTokenDescriptor, TokenValidationParameters, ExpectedException> RoundTripJWEParams() { var theoryData = new TheoryData <string, SecurityTokenDescriptor, TokenValidationParameters, ExpectedException>(); theoryData.Add( "Test1", Default.SymmetricEncryptSignSecurityTokenDescriptor(), Default.SymmetricEncyptSignTokenValidationParameters, ExpectedException.NoExceptionExpected ); theoryData.Add( "Test2", Default.SecurityTokenDescriptor(Default.SymmetricEncryptingCredentials, Default.SymmetricSigningCredentials, ClaimSets.DefaultClaims), Default.TokenValidationParameters(Default.SymmetricEncryptionKey256, Default.SymmetricSigningKey256), ExpectedException.NoExceptionExpected ); // signing key not found theoryData.Add( "Test3", Default.SymmetricEncryptSignSecurityTokenDescriptor(), new TokenValidationParameters { IssuerSigningKey = NotDefault.SymmetricSigningKey256, TokenDecryptionKey = Default.SymmetricEncryptionKey256, }, ExpectedException.SecurityTokenSignatureKeyNotFoundException("IDX10501:") ); // encryption key not found theoryData.Add( "Test4", Default.SymmetricEncryptSignSecurityTokenDescriptor(), new TokenValidationParameters { IssuerSigningKey = Default.SymmetricSigningKey256, TokenDecryptionKey = NotDefault.SymmetricEncryptionKey, }, ExpectedException.SecurityTokenDecryptionFailedException("IDX10609:") ); return(theoryData); }
private static TheoryData <int, BinaryOperatorKind> Build_RightCount_Diagnostic_TheoryData() { var theoryData = new TheoryData <int, BinaryOperatorKind>(); foreach (var fixerData in RightCount_Fixer_TheoryData) { theoryData.Add((int)fixerData[0], (BinaryOperatorKind)fixerData[1]); } return(theoryData); }
private static TheoryData <BinaryOperatorKind, int> Build_LeftCount_Diagnostic_TheoryData() { var theoryData = new TheoryData <BinaryOperatorKind, int>(); foreach (var fixerData in LeftCount_Fixer_TheoryData) { theoryData.Add((BinaryOperatorKind)fixerData[0], (int)fixerData[1]); } return(theoryData); }
public static TheoryData <Type> GetIsNotSimpleTheories() { var result = new TheoryData <Type>(); foreach (var type in GetNoneSimpleTypes()) { result.Add(type); } return(result); }
public static TheoryData<KeyValuePair<string, string[]>> CreditCards() { var json = File.ReadAllText("Data\\ValidCards.json"); var creditCards = JsonConvert.DeserializeObject<Dictionary<string, string[]>>(json); var data = new TheoryData<KeyValuePair<string, string[]>>(); foreach (var item in creditCards) { data.Add(item); } return data; }
private static TheoryData<string, string[]> GetInvalidNameOrPrefixData( Func<string, string, string> onNameError, string whitespaceErrorString, Func<string, string> onDataError) { // name, expectedErrorMessages var data = new TheoryData<string, string[]> { { "!", new[] { onNameError("!", "!") } }, { "hello!", new[] { onNameError("hello!", "!") } }, { "!hello", new[] { onNameError("!hello", "!") } }, { "he!lo", new[] { onNameError("he!lo", "!") } }, { "!he!lo!", new[] { onNameError("!he!lo!", "!"), onNameError("!he!lo!", "!"), onNameError("!he!lo!", "!"), } }, { "@", new[] { onNameError("@", "@") } }, { "hello@", new[] { onNameError("hello@", "@") } }, { "@hello", new[] { onNameError("@hello", "@") } }, { "he@lo", new[] { onNameError("he@lo", "@") } }, { "@he@lo@", new[] { onNameError("@he@lo@", "@"), onNameError("@he@lo@", "@"), onNameError("@he@lo@", "@"), } }, { "/", new[] { onNameError("/", "/") } }, { "hello/", new[] { onNameError("hello/", "/") } }, { "/hello", new[] { onNameError("/hello", "/") } }, { "he/lo", new[] { onNameError("he/lo", "/") } }, { "/he/lo/", new[] { onNameError("/he/lo/", "/"), onNameError("/he/lo/", "/"), onNameError("/he/lo/", "/"), } }, { "<", new[] { onNameError("<", "<") } }, { "hello<", new[] { onNameError("hello<", "<") } }, { "<hello", new[] { onNameError("<hello", "<") } }, { "he<lo", new[] { onNameError("he<lo", "<") } }, { "<he<lo<", new[] { onNameError("<he<lo<", "<"), onNameError("<he<lo<", "<"), onNameError("<he<lo<", "<"), } }, { "?", new[] { onNameError("?", "?") } }, { "hello?", new[] { onNameError("hello?", "?") } }, { "?hello", new[] { onNameError("?hello", "?") } }, { "he?lo", new[] { onNameError("he?lo", "?") } }, { "?he?lo?", new[] { onNameError("?he?lo?", "?"), onNameError("?he?lo?", "?"), onNameError("?he?lo?", "?"), } }, { "[", new[] { onNameError("[", "[") } }, { "hello[", new[] { onNameError("hello[", "[") } }, { "[hello", new[] { onNameError("[hello", "[") } }, { "he[lo", new[] { onNameError("he[lo", "[") } }, { "[he[lo[", new[] { onNameError("[he[lo[", "["), onNameError("[he[lo[", "["), onNameError("[he[lo[", "["), } }, { ">", new[] { onNameError(">", ">") } }, { "hello>", new[] { onNameError("hello>", ">") } }, { ">hello", new[] { onNameError(">hello", ">") } }, { "he>lo", new[] { onNameError("he>lo", ">") } }, { ">he>lo>", new[] { onNameError(">he>lo>", ">"), onNameError(">he>lo>", ">"), onNameError(">he>lo>", ">"), } }, { "]", new[] { onNameError("]", "]") } }, { "hello]", new[] { onNameError("hello]", "]") } }, { "]hello", new[] { onNameError("]hello", "]") } }, { "he]lo", new[] { onNameError("he]lo", "]") } }, { "]he]lo]", new[] { onNameError("]he]lo]", "]"), onNameError("]he]lo]", "]"), onNameError("]he]lo]", "]"), } }, { "=", new[] { onNameError("=", "=") } }, { "hello=", new[] { onNameError("hello=", "=") } }, { "=hello", new[] { onNameError("=hello", "=") } }, { "he=lo", new[] { onNameError("he=lo", "=") } }, { "=he=lo=", new[] { onNameError("=he=lo=", "="), onNameError("=he=lo=", "="), onNameError("=he=lo=", "="), } }, { "\"", new[] { onNameError("\"", "\"") } }, { "hello\"", new[] { onNameError("hello\"", "\"") } }, { "\"hello", new[] { onNameError("\"hello", "\"") } }, { "he\"lo", new[] { onNameError("he\"lo", "\"") } }, { "\"he\"lo\"", new[] { onNameError("\"he\"lo\"", "\""), onNameError("\"he\"lo\"", "\""), onNameError("\"he\"lo\"", "\""), } }, { "'", new[] { onNameError("'", "'") } }, { "hello'", new[] { onNameError("hello'", "'") } }, { "'hello", new[] { onNameError("'hello", "'") } }, { "he'lo", new[] { onNameError("he'lo", "'") } }, { "'he'lo'", new[] { onNameError("'he'lo'", "'"), onNameError("'he'lo'", "'"), onNameError("'he'lo'", "'"), } }, { "hello*", new[] { onNameError("hello*", "*") } }, { "*hello", new[] { onNameError("*hello", "*") } }, { "he*lo", new[] { onNameError("he*lo", "*") } }, { "*he*lo*", new[] { onNameError("*he*lo*", "*"), onNameError("*he*lo*", "*"), onNameError("*he*lo*", "*"), } }, { Environment.NewLine, new[] { whitespaceErrorString } }, { "\t", new[] { whitespaceErrorString } }, { " \t ", new[] { whitespaceErrorString } }, { " ", new[] { whitespaceErrorString } }, { Environment.NewLine + " ", new[] { whitespaceErrorString } }, { "! \t\r\n@/<>?[]=\"'*", new[] { onNameError("! \t\r\n@/<>?[]=\"'*", "!"), onNameError("! \t\r\n@/<>?[]=\"'*", " "), onNameError("! \t\r\n@/<>?[]=\"'*", "\t"), onNameError("! \t\r\n@/<>?[]=\"'*", "\r"), onNameError("! \t\r\n@/<>?[]=\"'*", "\n"), onNameError("! \t\r\n@/<>?[]=\"'*", "@"), onNameError("! \t\r\n@/<>?[]=\"'*", "/"), onNameError("! \t\r\n@/<>?[]=\"'*", "<"), onNameError("! \t\r\n@/<>?[]=\"'*", ">"), onNameError("! \t\r\n@/<>?[]=\"'*", "?"), onNameError("! \t\r\n@/<>?[]=\"'*", "["), onNameError("! \t\r\n@/<>?[]=\"'*", "]"), onNameError("! \t\r\n@/<>?[]=\"'*", "="), onNameError("! \t\r\n@/<>?[]=\"'*", "\""), onNameError("! \t\r\n@/<>?[]=\"'*", "'"), onNameError("! \t\r\n@/<>?[]=\"'*", "*"), } }, { "! \tv\ra\nl@i/d<>?[]=\"'*", new[] { onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "!"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", " "), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "\t"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "\r"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "\n"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "@"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "/"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "<"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", ">"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "?"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "["), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "]"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "="), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "\""), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "'"), onNameError("! \tv\ra\nl@i/d<>?[]=\"'*", "*"), } }, }; if (onDataError != null) { data.Add("data-", new[] { onDataError("data-") }); data.Add("data-something", new[] { onDataError("data-something") }); data.Add("Data-Something", new[] { onDataError("Data-Something") }); data.Add("DATA-SOMETHING", new[] { onDataError("DATA-SOMETHING") }); } return data; }
public static TheoryData<KeyValuePair<string, string[]>> CreditCards(CardIssuer cardIssuer) { var theoryData = new TheoryData<KeyValuePair<string, string[]>>(); foreach (var creditCard in CreditCards() .SelectMany(item => item.Cast<KeyValuePair<string, string[]>>()) .Where(x => x.Key.Equals(cardIssuer.ToString(), StringComparison.OrdinalIgnoreCase))) { theoryData.Add(creditCard); } return theoryData; }