protected void HelperVerifyVariousSizes(string size)
{
var path = TestData(Location) + "-size";
using (var verifier = new Verifier(path))
{
var activeSignature = (WebBase64) File.ReadAllLines(Path.Combine(path, size + ".out")).First();
Expect(verifier.Verify(Input, activeSignature), Is.True);
}
}
public void Verify()
{
var path = TestData(Location);
using (var verifier = new Verifier(path))
{
var activeSignature = (WebBase64) File.ReadAllLines(Path.Combine(path, "1.out")).First();
var primarySignature = (WebBase64) File.ReadAllLines(Path.Combine(path, "2.out")).First();
Expect(verifier.Verify(Input, activeSignature), Is.True);
Expect(verifier.Verify(Input, primarySignature), Is.True);
}
}
public static byte getNextState(Verifier v, byte b, byte s) {
return (byte) ( 0xFF &
(((v.states()[((
(s*v.stFactor()+(((v.cclass()[((b&0xFF)>>eidxSft4bits)])
>> ((b & eSftMsk4bits) << eBitSft4bits))
& eUnitMsk4bits ))&0xFF)
>> eidxSft4bits) ]) >> (((
(s*v.stFactor()+(((v.cclass()[((b&0xFF)>>eidxSft4bits)])
>> ((b & eSftMsk4bits) << eBitSft4bits))
& eUnitMsk4bits ))&0xFF)
& eSftMsk4bits) << eBitSft4bits)) & eUnitMsk4bits )
) ;
}
public void TestSignImport([Values("rsa", "dsa")] String keyType, [Values("pem", "der")] String fileFormat)
{
using (var signer = new Signer(Util.TestDataPath(TEST_DATA, keyType + "-sign")))
{
var signature = signer.Sign(input);
using (
var keyset = ImportedKeySet.Import.X509Certificate(KeyPurpose.Verify,
Util.TestDataPath(TEST_DATA,
keyType + "-sign-crt." +
fileFormat)))
using (var verifier = new Verifier(keyset))
{
Expect(verifier.Verify(input, signature), Is.True);
}
}
}
public override bool Execute()
{
var defineConstants = DefineConstants.GetConstants();
var verifier = new Verifier
{
Logger = new BuildLogger
{
BuildEngine = BuildEngine,
},
SolutionDirectory= SolutionDir,
ProjectDirectory = ProjectDirectory,
DefineConstants = defineConstants,
TargetPath = TargetPath,
};
return verifier.Verify();
}
public void ConsoleLogging()
{
Verifier.VerifyAnalyzer(@"TestCases\ConsoleLogging.cs", new ConsoleLogging());
}
public void OptionExplicitOn_IsMissing() =>
Verifier.VerifyVisualBasicAnalyzer("Option Strict Off", new OptionExplicitOn());
public void OptionExplicitOn_IsOff() =>
Verifier.VerifyVisualBasicAnalyzer("Option Explicit Off ' Noncompliant ^1#19 {{Change this to 'Option Explicit On'.}}", new OptionExplicitOn());
public void DangerousGetHandleShouldNotBeCalled_CS_CSharp9() =>
Verifier.VerifyAnalyzerFromCSharp9Console(@"TestCases\DangerousGetHandleShouldNotBeCalled.CSharp9.cs",
new CS.DangerousGetHandleShouldNotBeCalled(),
MetadataReferenceFacade.MicrosoftWin32Registry);
public void ForLoopCounterChanged()
{
Verifier.Verify(@"TestCases\ForLoopCounterChanged.cs", new ForLoopCounterChanged());
}
public void ThreadResumeOrSuspendShouldNotBeCalled_VB()
{
Verifier.VerifyAnalyzer(@"TestCases\ThreadResumeOrSuspendShouldNotBeCalled.vb",
new vbnet.ThreadResumeOrSuspendShouldNotBeCalled());
}
public void PropertyGetterWithThrowVBNet()
{
Verifier.VerifyAnalyzer(@"TestCases\PropertyGetterWithThrow.vb", new VB.PropertyGetterWithThrow());
}
public void PropertyGetterWithThrowCSharp()
{
Verifier.VerifyAnalyzer(@"TestCases\PropertyGetterWithThrow.cs", new CS.PropertyGetterWithThrow());
}
public void IndexedPropertyWithMultipleParameters()
{
Verifier.VerifyAnalyzer(@"TestCases\IndexedPropertyWithMultipleParameters.vb", new IndexedPropertyWithMultipleParameters());
}
public void FunctionName()
{
Verifier.VerifyAnalyzer(@"TestCases\FunctionName.vb", new FunctionName());
}
public void ShortCircuitNullPointerDereference()
{
Verifier.VerifyAnalyzer(@"TestCases\ShortCircuitNullPointerDereference.cs", new ShortCircuitNullPointerDereference());
}
public void GenericTypeParameterInOut()
{
Verifier.VerifyAnalyzer(@"TestCases\GenericTypeParameterInOut.cs", new GenericTypeParameterInOut());
}
public void StringConcatenationInLoop()
{
Verifier.VerifyAnalyzer(@"TestCases\StringConcatenationInLoop.cs", new CS.StringConcatenationInLoop());
Verifier.VerifyAnalyzer(@"TestCases\StringConcatenationInLoop.vb", new VB.StringConcatenationInLoop());
}
public void TestPublicVerify(String subDir, string nestDir)
{
var subPath = Util.TestDataPath(TEST_DATA, subDir, nestDir);
using (var verifier = new Verifier(subPath))
using (var publicVerifier = new Verifier(subPath + ".public"))
{
var activeSignature = (WebBase64) File.ReadAllLines(Path.Combine(subPath, "1.out")).First();
var primarySignature = (WebBase64) File.ReadAllLines(Path.Combine(subPath, "2.out")).First();
Expect(verifier.Verify(input, activeSignature), Is.True);
Expect(verifier.Verify(input, primarySignature), Is.True);
Expect(publicVerifier.Verify(input, activeSignature), Is.True);
Expect(publicVerifier.Verify(input, primarySignature), Is.True);
}
}
public void MemberShadowsOuterStaticMember() => Verifier.VerifyAnalyzer(@"TestCases\MemberShadowsOuterStaticMember.cs", new CS.MemberShadowsOuterStaticMember());
public void ThreadResumeOrSuspendShouldNotBeCalled()
{
Verifier.VerifyAnalyzer(@"TestCases\ThreadResumeOrSuspendShouldNotBeCalled.cs",
new csharp.ThreadResumeOrSuspendShouldNotBeCalled());
}
public void MemberShadowsOuterStaticMember_CSharp9() => Verifier.VerifyAnalyzerFromCSharp9Library(@"TestCases\MemberShadowsOuterStaticMember.CSharp9.cs", new CS.MemberShadowsOuterStaticMember());
public void UnsignedTypesUsage()
{
Verifier.VerifyAnalyzer(@"TestCases\UnsignedTypesUsage.vb", new UnsignedTypesUsage());
}
public void ReferenceEqualsOnValueType()
{
Verifier.VerifyAnalyzer(@"TestCases\ReferenceEqualsOnValueType.cs", new ReferenceEqualsOnValueType());
}
public void PeVerify()
{
Verifier.Verify(AssemblyWeaver.BeforeAssemblyPath, AssemblyWeaver.AfterAssemblyPath);
}
public void GetHashCodeEqualsOverride() =>
Verifier.VerifyAnalyzer(@"TestCases\GetHashCodeEqualsOverride.cs",
new CS.GetHashCodeEqualsOverride(),
MetadataReferenceFacade.SystemComponentModelPrimitives);
public void DangerousGetHandleShouldNotBeCalled_VB() =>
Verifier.VerifyAnalyzer(@"TestCases\DangerousGetHandleShouldNotBeCalled.vb",
new VB.DangerousGetHandleShouldNotBeCalled());
public void GetHashCodeEqualsOverride_CSharp9() =>
Verifier.VerifyAnalyzerFromCSharp9Library(@"TestCases\GetHashCodeEqualsOverride.CSharp9.cs",
new CS.GetHashCodeEqualsOverride(),
additionalReferences: MetadataReferenceFacade.SystemComponentModelPrimitives);
public void OptionExplicitOn_IsOn() =>
Verifier.VerifyVisualBasicAnalyzer("Option Explicit On", new OptionExplicitOn());
public void NoExceptionInFinally()
{
Verifier.VerifyAnalyzer(@"TestCases\NoExceptionsInFinally.cs", new NoExceptionsInFinally());
}
public void AsyncAwaitIdentifier()
{
Verifier.VerifyAnalyzer(@"TestCases\AsyncAwaitIdentifier.cs", new AsyncAwaitIdentifier());
}
protected override void Dispose(bool disposing)
{
_verifier = _verifier.SafeDispose();
base.Dispose(disposing);
}
public void ConditionalStructureSameImplementation_Switch_CSharp()
{
Verifier.VerifyAnalyzer(@"TestCases\ConditionalStructureSameImplementation_Switch.cs",
new SonarAnalyzer.Rules.CSharp.ConditionalStructureSameImplementation());
}
public void RequireAttributeUsageAttribute()
{
Verifier.VerifyAnalyzer(@"TestCases\RequireAttributeUsageAttribute.cs",
new RequireAttributeUsageAttribute());
}
public void TestSignImport(
[Values("rsa", "dsa")] string keyType,
[Values("pem", "der")] string format)
{
using (var keystream = HelperOpenPkcsStream(keyType, format, "sign"))
using (
var keyset = ImportedKeySet.Import.PkcsKey(KeyPurpose.SignAndVerify, keystream, () => "pass"
/* hard coding for test only!!!!*/))
using (var signer = new Signer(keyset))
{
var signature = signer.Sign(input);
using (var verifier = new Verifier(Util.TestDataPath(TEST_DATA, keyType + "-sign-pub")))
{
Expect(verifier.Verify(input, signature), Is.True);
}
}
}
public void ConditionalStructureSameImplementation_Switch_VisualBasic()
{
Verifier.VerifyAnalyzer(@"TestCases\ConditionalStructureSameImplementation_Switch.vb",
new SonarAnalyzer.Rules.VisualBasic.ConditionalStructureSameImplementation());
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeoutVerifier" /> class.
/// </summary>
/// <param name="keySet">The key set.</param>
/// <param name="currentDateTime">The current date time provider.</param>
public TimeoutVerifier(IKeySet keySet, Func<DateTime> currentDateTime = null)
: base(keySet)
{
_verifier = new TimeoutVerifierHelper(keySet);
_currentDateTime = currentDateTime ?? (()=> DateTime.Now);
}
public void CompareNaN()
{
Verifier.VerifyAnalyzer(@"TestCases\CompareNaN.cs", new CompareNaN());
}
public void TestPublicVerifySizes(String subDir, string nestDir)
{
var subPath = Util.TestDataPath(TEST_DATA, subDir, nestDir);
var ks = new KeySet(subPath);
using (var verifier = new Verifier(subPath))
using (var publicVerifier = new Verifier(subPath + ".public"))
{
foreach (var size in ks.Metadata.KeyType.KeySizeOptions)
{
var activeSignature =
(WebBase64) File.ReadAllLines(Path.Combine(subPath, String.Format("{0}.out", size))).First();
Expect(verifier.Verify(input, activeSignature), Is.True);
Expect(publicVerifier.Verify(input, activeSignature), Is.True);
}
}
}
public void RestrictDeserializedTypesLosFormatter() =>
Verifier.VerifyAnalyzer(@"TestCases\RestrictDeserializedTypes.LosFormatter.cs",
GetAnalyzer(),
ParseOptionsHelper.FromCSharp8,
additionalReferences: GetAdditionalReferences());
