private static void ValidateChecksumPragma(CodeChecksumPragma e)
{
if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
{
throw new ArgumentException(SR.GetString("InvalidPathCharsInChecksum", new object[] { e.FileName }));
}
}
private static void ValidateChecksumPragma(CodeChecksumPragma e)
{
if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
{
throw new ArgumentException(SR.Format(SR.InvalidPathCharsInChecksum, e.FileName));
}
}
public void Constructor1()
{
string fileName = "mono";
Guid algorithmId = Guid.NewGuid();
byte[] data = new byte[] { 0, 1 };
CodeChecksumPragma ccp = new CodeChecksumPragma(fileName, algorithmId, data);
Assert.AreEqual(algorithmId, ccp.ChecksumAlgorithmId, "#1");
Assert.AreEqual(data, ccp.ChecksumData, "#2");
Assert.AreEqual(fileName, ccp.FileName, "#3");
Assert.AreSame(data, ccp.ChecksumData, "#4");
Assert.AreSame(fileName, ccp.FileName, "#5");
ccp.ChecksumAlgorithmId = Guid.Empty;
Assert.AreEqual(Guid.Empty, ccp.ChecksumAlgorithmId, "#6");
ccp.ChecksumData = null;
Assert.IsNull(ccp.ChecksumData, "#7");
ccp.FileName = null;
Assert.IsNotNull(ccp.FileName, "#8");
Assert.AreEqual(string.Empty, ccp.FileName, "#9");
ccp = new CodeChecksumPragma((string)null, Guid.Empty, (byte[])null);
Assert.AreEqual(Guid.Empty, ccp.ChecksumAlgorithmId, "#10");
Assert.IsNull(ccp.ChecksumData, "#11");
Assert.IsNotNull(ccp.FileName, "#12");
Assert.AreEqual(string.Empty, ccp.FileName, "#13");
}
private void AddChecksumPragma(System.Web.Compilation.BuildProvider buildProvider, CodeCompileUnit compileUnit)
{
if (((buildProvider != null) && (buildProvider.VirtualPath != null)) && this._compilerType.CompilerParameters.IncludeDebugInformation)
{
string path = HostingEnvironment.MapPathInternal(buildProvider.VirtualPath);
if (File.Exists(path))
{
if (!s_hashMD5Guid.HasValue)
{
s_hashMD5Guid = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 240, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99);
}
CodeChecksumPragma pragma = new CodeChecksumPragma();
if (this._compConfig.UrlLinePragmas)
{
pragma.FileName = ErrorFormatter.MakeHttpLinePragma(buildProvider.VirtualPathObject.VirtualPathString);
}
else
{
pragma.FileName = path;
}
pragma.ChecksumAlgorithmId = s_hashMD5Guid.Value;
using (Stream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
pragma.ChecksumData = this.ComputeHash(stream);
}
compileUnit.StartDirectives.Add(pragma);
}
}
}
public void Constructor0_Deny_Unrestricted()
{
CodeChecksumPragma ccp = new CodeChecksumPragma();
Assert.AreEqual(Guid.Empty, ccp.ChecksumAlgorithmId, "ChecksumAlgorithmId");
ccp.ChecksumAlgorithmId = Guid.NewGuid();
Assert.IsNull(ccp.ChecksumData, "ChecksumData");
ccp.ChecksumData = new byte [1];
Assert.AreEqual(String.Empty, ccp.FileName, "FileName");
}
public void Constructor1_Deny_Unrestricted()
{
Guid g = Guid.NewGuid();
CodeChecksumPragma ccp = new CodeChecksumPragma("mono", g, new byte [1]);
Assert.AreEqual(g, ccp.ChecksumAlgorithmId, "ChecksumAlgorithmId");
ccp.ChecksumAlgorithmId = Guid.Empty;
Assert.AreEqual(1, ccp.ChecksumData.Length, "ChecksumData");
ccp.ChecksumData = new byte[0];
Assert.AreEqual("mono", ccp.FileName, "FileName");
}
public void Constructor0()
{
CodeChecksumPragma ccp = new CodeChecksumPragma();
Assert.AreEqual(Guid.Empty, ccp.ChecksumAlgorithmId, "#1");
Assert.IsNull(ccp.ChecksumData, "#2");
Assert.IsNotNull(ccp.FileName, "#3");
Assert.AreEqual(string.Empty, ccp.FileName, "#4");
ccp.FileName = null;
Assert.IsNotNull(ccp.FileName, "#5");
Assert.AreEqual(string.Empty, ccp.FileName, "#6");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
// VB code provider doesn't currently generate checksum statements. This
// will be completed before the next release of the CLR.
// JScript does not currently support checksum pragmas.
if (!(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) {
// GENERATES (C#):
// #pragma checksum "c:\foo\bar\OuterLinePragma.txt" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "DEAD"
// #pragma checksum "bogus.txt" "{ff1816ec-aa5e-4d10-87f7-6f4963833460}" "F00BAA"
// #pragma checksum "" "{00000000-0000-0000-0000-000000000000}" ""
//
// // Namespace Comment
// namespace Namespace1 {
//
//
// // Outer Type Comment
//
// #line 300 "c:\foo\bar\OuterLinePragma.txt"
// public class Class1 {
//
// public void Method1() {
// }
//
// // Method 2 Comment
// public void Method2() {
// }
// }
//
// #line default
// #line hidden
// }
AddScenario ("CheckPragmasInSrcCode", "Checks to see if the pragmas are in the generated source code.");
CodeChecksumPragma pragma1 = new CodeChecksumPragma();
pragma1.FileName = "c:\\foo\\bar\\OuterLinePragma.txt";
pragma1.ChecksumAlgorithmId = HashMD5;
pragma1.ChecksumData = new byte[] {0xDE, 0xAD};
cu.StartDirectives.Add(pragma1);
CodeChecksumPragma pragma2 = new CodeChecksumPragma("bogus.txt", HashSHA1, new byte[]{0xF0, 0x0B, 0xAA});
cu.StartDirectives.Add(pragma2);
CodeChecksumPragma pragma3 = new CodeChecksumPragma();
cu.StartDirectives.Add(pragma3);
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Comments.Add(new CodeCommentStatement("Namespace Comment"));
cu.Namespaces.Add(ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1");
ns.Types.Add(cd);
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
cd.LinePragma = new CodeLinePragma("c:\\foo\\bar\\OuterLinePragma.txt", 300);
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
cd.Members.Add(method1);
cd.Members.Add(method2);
}
#endif
}
protected virtual void Visit(CodeChecksumPragma directive)
{
}
protected override void Visit(CodeChecksumPragma directive)
{
base.Visit(directive);
}
internal void ConstructType()
{
unit = new CodeCompileUnit();
byte[] md5checksum = parser.MD5Checksum;
if (md5checksum != null)
{
CodeChecksumPragma pragma = new CodeChecksumPragma();
pragma.FileName = parser.InputFile;
pragma.ChecksumAlgorithmId = HashMD5;
pragma.ChecksumData = md5checksum;
unit.StartDirectives.Add(pragma);
}
if (parser.IsPartial)
{
string partialns = null;
string partialclasstype = parser.PartialClassName;
int partialdot = partialclasstype.LastIndexOf('.');
if (partialdot != -1)
{
partialns = partialclasstype.Substring(0, partialdot);
partialclasstype = partialclasstype.Substring(partialdot + 1);
}
CodeNamespace partialNS = new CodeNamespace(partialns);
partialClass = new CodeTypeDeclaration(partialclasstype);
partialClass.IsPartial = true;
partialClassExpr = new CodeTypeReferenceExpression(parser.PartialClassName);
unit.Namespaces.Add(partialNS);
partialClass.TypeAttributes = TypeAttributes.Public;
partialNS.Types.Add(partialClass);
}
string mainclasstype = parser.ClassName;
string mainns = DEFAULT_NAMESPACE;
int maindot = mainclasstype.LastIndexOf('.');
if (maindot != -1)
{
mainns = mainclasstype.Substring(0, maindot);
mainclasstype = mainclasstype.Substring(maindot + 1);
}
mainNS = new CodeNamespace(mainns);
mainClass = new CodeTypeDeclaration(mainclasstype);
CodeTypeReference baseTypeRef;
if (partialClass != null)
{
baseTypeRef = new CodeTypeReference(parser.PartialClassName);
baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
}
else
{
baseTypeRef = new CodeTypeReference(parser.BaseType.FullName);
if (parser.BaseTypeIsGlobal)
{
baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
}
}
mainClass.BaseTypes.Add(baseTypeRef);
mainClassExpr = new CodeTypeReferenceExpression(mainns + "." + mainclasstype);
unit.Namespaces.Add(mainNS);
mainClass.TypeAttributes = TypeAttributes.Public;
mainNS.Types.Add(mainClass);
foreach (object o in parser.Imports.Keys)
{
if (o is string)
{
mainNS.Imports.Add(new CodeNamespaceImport((string)o));
}
}
// StringCollection.Contains has O(n) complexity, but
// considering the number of comparisons we make on
// average and the fact that using an intermediate array
// would be even more costly, this is fine here.
StringCollection refAsm = unit.ReferencedAssemblies;
string asmName;
if (parser.Assemblies != null)
{
foreach (object o in parser.Assemblies)
{
asmName = o as string;
if (asmName != null && !refAsm.Contains(asmName))
{
refAsm.Add(asmName);
}
}
}
ArrayList al = WebConfigurationManager.ExtraAssemblies;
if (al != null && al.Count > 0)
{
foreach (object o in al)
{
asmName = o as string;
if (asmName != null && !refAsm.Contains(asmName))
{
refAsm.Add(asmName);
}
}
}
IList list = BuildManager.CodeAssemblies;
if (list != null && list.Count > 0)
{
Assembly asm;
foreach (object o in list)
{
asm = o as Assembly;
if (o == null)
{
continue;
}
asmName = asm.Location;
if (asmName != null && !refAsm.Contains(asmName))
{
refAsm.Add(asmName);
}
}
}
// Late-bound generators specifics (as for MonoBASIC/VB.NET)
unit.UserData["RequireVariableDeclaration"] = parser.ExplicitOn;
unit.UserData["AllowLateBound"] = !parser.StrictOn;
InitializeType();
AddInterfaces();
AddClassAttributes();
CreateStaticFields();
AddApplicationAndSessionObjects();
AddScripts();
CreateMethods();
CreateConstructor(null, null);
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu)
{
#if WHIDBEY
// VB code provider doesn't currently generate checksum statements. This
// will be completed before the next release of the CLR.
// JScript does not currently support checksum pragmas.
if (!(provider is VBCodeProvider) && !(provider is JScriptCodeProvider))
{
// GENERATES (C#):
// #pragma checksum "c:\foo\bar\OuterLinePragma.txt" "{406ea660-64cf-4c82-b6f0-42d48172a799}" "DEAD"
// #pragma checksum "bogus.txt" "{ff1816ec-aa5e-4d10-87f7-6f4963833460}" "F00BAA"
// #pragma checksum "" "{00000000-0000-0000-0000-000000000000}" ""
//
// // Namespace Comment
// namespace Namespace1 {
//
//
// // Outer Type Comment
//
// #line 300 "c:\foo\bar\OuterLinePragma.txt"
// public class Class1 {
//
// public void Method1() {
// }
//
// // Method 2 Comment
// public void Method2() {
// }
// }
//
// #line default
// #line hidden
// }
AddScenario("CheckPragmasInSrcCode", "Checks to see if the pragmas are in the generated source code.");
CodeChecksumPragma pragma1 = new CodeChecksumPragma();
pragma1.FileName = "c:\\foo\\bar\\OuterLinePragma.txt";
pragma1.ChecksumAlgorithmId = HashMD5;
pragma1.ChecksumData = new byte[] { 0xDE, 0xAD };
cu.StartDirectives.Add(pragma1);
CodeChecksumPragma pragma2 = new CodeChecksumPragma("bogus.txt", HashSHA1, new byte[] { 0xF0, 0x0B, 0xAA });
cu.StartDirectives.Add(pragma2);
CodeChecksumPragma pragma3 = new CodeChecksumPragma();
cu.StartDirectives.Add(pragma3);
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Comments.Add(new CodeCommentStatement("Namespace Comment"));
cu.Namespaces.Add(ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration("Class1");
ns.Types.Add(cd);
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
cd.LinePragma = new CodeLinePragma("c:\\foo\\bar\\OuterLinePragma.txt", 300);
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
cd.Members.Add(method1);
cd.Members.Add(method2);
}
#endif
}
private static void ValidateChecksumPragma(CodeChecksumPragma e)
{
if (e.FileName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
throw new ArgumentException(SR.Format(SR.InvalidPathCharsInChecksum, e.FileName));
}
