public static string GetOptions(ProgrammingLanguages PL)
{
lock (lockObj)
{
return(options.ContainsKey(PL) ? options[PL] : String.Empty);
}
}
public static string GetOptions(ProgrammingLanguages PL)
{
lock (lockObj)
{
return options.ContainsKey(PL) ? options[PL] : String.Empty;
}
}
public static IEnumerable <object[]> GetProjectTemplates()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
Configuration.Current.CdnUrl = "https://wtsrepository.blob.core.windows.net/pro/";
InitializeTemplates(new LegacyTemplatesSourceV2(), language);
// TODO: Re-enable for all platforms
////foreach (var language in Platforms.GetAllPlarforms())
var projectTypes = GenContext.ToolBox.Repo.GetProjectTypes()
.Where(m => !string.IsNullOrEmpty(m.Description))
.Select(m => m.Name);
foreach (var projectType in projectTypes)
{
// TODO: Re-enable for all platforms
// var projectFrameworks = GenComposer.GetSupportedFx(projectType, string.Empty);
var targetFrameworks = GenContext.ToolBox.Repo.GetFrameworks()
.Select(m => m.Name).ToList();
foreach (var framework in targetFrameworks)
{
result.Add(new object[] { projectType, framework, Platforms.Uwp, language });
}
}
}
return(result);
}
public static async Task <IEnumerable <object[]> > GetProjectTemplatesAsync()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
await InitializeTemplatesForLanguageAsync(new LegacyTemplatesSource(), language);
var projectTemplates = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetTemplateType() == TemplateType.Project &&
t.GetLanguage() == language);
foreach (var projectTemplate in projectTemplates)
{
var projectTypeList = projectTemplate.GetProjectTypeList();
foreach (var projectType in projectTypeList)
{
var frameworks = GenComposer.GetSupportedFx(projectType);
foreach (var framework in frameworks)
{
result.Add(new object[] { projectType, framework, language });
}
}
}
}
return(result);
}
public static IEnumerable <object[]> GetProjectTemplates()
{
InitializeTemplates(new LocalTemplatesSource("TstBld"));
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
SetCurrentLanguage(language);
var projectTypes = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetTemplateType() == TemplateType.Project &&
t.GetLanguage() == language).SelectMany(p => p.GetProjectTypeList()).Distinct();
foreach (var projectType in projectTypes)
{
var frameworks = GenComposer.GetSupportedFx(projectType);
foreach (var framework in frameworks)
{
result.Add(new object[] { projectType, framework, language });
}
}
}
return(result);
}
public static IEnumerable <object[]> GetProjectTemplates()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
if (language == ProgrammingLanguages.Any)
{
continue;
}
Configuration.Current.CdnUrl = "https://wtsrepository.blob.core.windows.net/pro/";
InitializeTemplates(new LegacyTemplatesSourceV2(language), language);
var projectTypes = GenContext.ToolBox.Repo.GetProjectTypes(Platforms.Uwp)
.Where(m => !string.IsNullOrEmpty(m.Description))
.Select(m => m.Name);
foreach (var projectType in projectTypes)
{
var targetFrameworks = GenContext.ToolBox.Repo.GetFrontEndFrameworks(Platforms.Uwp, projectType)
.Select(m => m.Name).ToList();
foreach (var framework in targetFrameworks)
{
result.Add(new object[] { projectType, framework, Platforms.Uwp, language });
}
}
}
return(result);
}
public static IEnumerable <object[]> GetPageAndFeatureTemplates()
{
InitializeTemplates(new LocalTemplatesSource("TstBld"));
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
var projectTypes = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetTemplateType() == TemplateType.Project &&
t.GetLanguage() == language).SelectMany(p => p.GetProjectTypeList()).Distinct();
foreach (var projectType in projectTypes)
{
var frameworks = GenComposer.GetSupportedFx(projectType);
foreach (var framework in frameworks)
{
var itemTemplates = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetFrameworkList().Contains(framework) &&
(t.GetTemplateType() == TemplateType.Page || t.GetTemplateType() == TemplateType.Feature) &&
t.GetLanguage() == language &&
!t.GetIsHidden());
foreach (var itemTemplate in itemTemplates)
{
result.Add(new object[]
{ itemTemplate.Name, projectType, framework, itemTemplate.Identity, language });
}
}
}
}
return(result);
}
public void TestOpen(Int32 ProblemID, Int32 SolutionID, string SolutionName,
ProgrammingLanguages PL, TournamentFormats TF,
out TestResults Result, out int Score)
{
// TODO: FL
Result = TestResults.RTE;
Score = 0;
File.Copy(LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\checker.exe",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe", true);
// Test
CheckSolutionOutput(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe",
LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\OpenProblemResult",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\" + SolutionName,
LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\OpenProblemResult",
out Result);
if (Result == TestResults.OK)
{
Score = 100;
}
}
private Boolean __CreateProvider(ProgrammingLanguages programmingLanguage, ref CodeDomProvider provider)
{
Boolean hasTheProvider = new Boolean();
String language = programmingLanguage.ToString();
switch (programmingLanguage)
{
case ProgrammingLanguages.CSharp:
hasTheProvider = CodeDomProvider.IsDefinedLanguage(language);
break;
case ProgrammingLanguages.VisualBasic:
hasTheProvider = CodeDomProvider.IsDefinedLanguage(language);
break;
default: /* C# Programming Language. */
language = "C#";
hasTheProvider = !hasTheProvider;
break;
}
;
provider = CodeDomProvider.CreateProvider(language);
return(hasTheProvider);
}
public static IEnumerable <object[]> GetAllLanguages()
{
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
yield return(new object[] { language });
}
}
////This test sets up projects for further manual tests. It generates legacy projects with all pages and features.
#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
public async Task GenerateLegacyProjectWithAllPagesAndFeaturesAsync(string projectType, string framework, string platform, string language)
#pragma warning restore xUnit1026 // Theory methods should use all of their parameters
{
var fixture = _fixture as BuildRightClickWithLegacyFixture;
if (language == ProgrammingLanguages.VisualBasic)
{
fixture.ChangeTemplatesSource(fixture.VBSource, language, Platforms.Uwp);
}
var projectName = $"{ProgrammingLanguages.GetShortProgrammingLanguage(language)}{ShortProjectType(projectType)}{framework}AllLegacy";
Func <ITemplateInfo, bool> selector =
t => t.GetTemplateType() == TemplateType.Project &&
t.GetProjectTypeList().Contains(projectType) &&
t.GetFrameworkList().Contains(framework) &&
!t.GetIsHidden() &&
t.GetLanguage() == language;
Func <ITemplateInfo, bool> templateSelector =
t => (t.GetTemplateType() == TemplateType.Page || t.GetTemplateType() == TemplateType.Feature) &&
t.GetFrameworkList().Contains(framework) &&
t.GetPlatform() == platform &&
!t.GetIsHidden();
var projectPath = await AssertGenerateProjectAsync(selector, projectName, projectType, framework, platform, language, templateSelector, BaseGenAndBuildFixture.GetDefaultName, false);
}
public static IEnumerable <object[]> GetProjectTemplates()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
Configuration.Current.CdnUrl = "https://wtsrepository.blob.core.windows.net/pro/";
InitializeTemplates(new LegacyTemplatesSourceV2(), language);
var projectTypes = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetTemplateType() == TemplateType.Project &&
t.GetLanguage() == language).SelectMany(p => p.GetProjectTypeList()).Distinct();
foreach (var projectType in projectTypes)
{
var frameworks = GenComposer.GetSupportedFx(projectType);
foreach (var framework in frameworks)
{
// See https://github.com/Microsoft/WindowsTemplateStudio/issues/1985
if (framework == "MVVMLight")
{
continue;
}
result.Add(new object[] { projectType, framework, language });
}
}
}
return(result);
}
public static string GetCommand(ProgrammingLanguages PL)
{
lock (lockObj)
{
return(command.ContainsKey(PL) ? command[PL] : String.Empty);
}
}
public static async Task <IEnumerable <object[]> > GetProjectTemplatesAsync()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
Configuration.Current.CdnUrl = "https://wtsrepository.blob.core.windows.net/pro/";
await InitializeTemplatesAsync(new LegacyTemplatesSourceV2(), language);
var projectTypes = GenContext.ToolBox.Repo.GetAll().Where(t => t.GetTemplateType() == TemplateType.Project &&
t.GetLanguage() == language).SelectMany(p => p.GetProjectTypeList()).Distinct();
foreach (var projectType in projectTypes)
{
var frameworks = GenComposer.GetSupportedFx(projectType);
foreach (var framework in frameworks)
{
result.Add(new object[] { projectType, framework, language });
}
}
}
return(result);
}
protected static IEnumerable <object[]> GetAllProjectTemplates()
{
List <object[]> result = new List <object[]>();
foreach (var language in ProgrammingLanguages.GetAllLanguages())
{
SetCurrentLanguage(language);
foreach (var platform in Platforms.GetAllPlatforms())
{
SetCurrentPlatform(platform);
var projectTypes = GenContext.ToolBox.Repo.GetProjectTypes(platform)
.Where(m => !string.IsNullOrEmpty(m.Description))
.Select(m => m.Name);
foreach (var projectType in projectTypes)
{
var targetFrameworks = GenContext.ToolBox.Repo.GetFrontEndFrameworks(platform, projectType)
.Select(m => m.Name).ToList();
foreach (var framework in targetFrameworks)
{
result.Add(new object[] { projectType, framework, platform, language });
}
}
}
}
return(result);
}
public static string GetPath(ProgrammingLanguages PL)
{
lock (lockPath)
{
return path.ContainsKey(PL) ? path[PL] : String.Empty;
}
}
public static string GetPath(ProgrammingLanguages PL)
{
lock (lockPath)
{
return(path.ContainsKey(PL) ? path[PL] : String.Empty);
}
}
public static void WhichLanguageDoYouPrefer(ProgrammingLanguages language)
{
switch (language)
{
case ProgrammingLanguages.C_Sharp:
Console.WriteLine($"1) You like to code in {ProgrammingLanguages.C_Sharp.ToString().Replace("_"," ")}, index {Convert.ToInt32(ProgrammingLanguages.C_Sharp)}");
break;
case ProgrammingLanguages.C_PlusPlus:
Console.WriteLine($"1) You like to code in {ProgrammingLanguages.C_PlusPlus.ToString().Replace("_PlusPlus"," ++")}, index {Convert.ToInt32(ProgrammingLanguages.C_PlusPlus)}");
break;
case ProgrammingLanguages.Java:
Console.WriteLine($"1) You like to code in {ProgrammingLanguages.Java.ToString()}, index {Convert.ToInt32(ProgrammingLanguages.Java)}");
break;
case ProgrammingLanguages.Python:
Console.WriteLine($"1) You like to code in {ProgrammingLanguages.Python.ToString()}, index {Convert.ToInt32(ProgrammingLanguages.Python)}");
break;
case ProgrammingLanguages.Fortran:
Console.WriteLine($"1) You like to code in {ProgrammingLanguages.Fortran.ToString()}, index {Convert.ToInt32(ProgrammingLanguages.Fortran)}");
break;
default:
throw new Exception("1) Not a valid entry.");
}
}
public static string GetCommand(ProgrammingLanguages PL)
{
lock (lockObj)
{
return command.ContainsKey(PL) ? command[PL] : String.Empty;
}
}
private void OnAddExecute()
{
var wrapper = new ProgrammingLanguageWrapper(new FriendsShow.Model.ProgrammingLanguage());
wrapper.PropertyChanged += Wrapper_PropertyChanged;
_programmingLanguageRepository.Add(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
}
public ItEmployee(string firstName, int stringID, string department, string programmingLanguage) : base(firstName, stringID, department)
{
this.ProgrammingLanguage = ProgrammingLanguage;
//ProgrammingLanguages temp1;
//Enum.TryParse(programmingLanguage, out temp1);
//this.ProgrammingLanguage = temp1;
}
public RemoteTemplatesSource(string platform, string language, string installedPackagePath, IDigitalSignatureService digitalSignatureService)
{
Platform = platform;
Language = ProgrammingLanguages.GetShortProgrammingLanguage(language);
InstalledPackagePath = installedPackagePath;
_templatePackage = new TemplatePackage(digitalSignatureService);
CanGetNewContent = digitalSignatureService.CanVerifySignatures;
}
private void OnAddExecute()
{
var wrapper = new ProgrammingLanguageWrapper(new Model.ProgrammingLanguage());
wrapper.PropertyChanged += Wrapper_PropertyChanged;
_programmingLanguageRepository.Add(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
wrapper.Name = string.Empty;
}
private Boolean __CodeGenerator()
{
ProgrammingLanguages pl = this.ProgrammingLanguage;
AssemblyInformation ai = this.AssemblyInformation;
String assemblyName = ai.Name;
String rootNamespace = this.RootNamespace;
TypeInformation[] types = ai.Types;
Int32 index = new Int32();
this.__CreateProvider(pl, ref this._provider);
CodeCompileUnit compileUnit = new CodeCompileUnit();
/* Declare a new namespace. */
CodeNamespace rn = new CodeNamespace(rootNamespace);
CodeNamespaceImport[] cnic = new CodeNamespaceImport[ai.Imports.Length];
for ( ; index < ai.Imports.Length; index++)
{
cnic[index] = new CodeNamespaceImport(ai.Imports[index]);
}
rn.Imports.AddRange(cnic);
/* Create new types. */
CodeTypeDeclaration[] ctd = new CodeTypeDeclaration[types.Length];
/* Declare new type. */
for (index = new Int32(); index < types.Length; index++)
{
FieldInformation[] _fields = types[index].Fields;
ctd[index] = new CodeTypeDeclaration(types[index].Name);
/* For each code type, create the field members. */
for (Int32 fIndex = new Int32(); fIndex < _fields.Length; fIndex++)
{
ctd[index].Members.Add(new CodeMemberField(_fields[fIndex].TypeReference, _fields[index].Name));
ctd[index].Members[index].Attributes = ( MemberAttributes )_fields[fIndex].Attributes;
}
;
}
;
rn.Types.AddRange(ctd);
/* Adds the new namespace to the compile unit. */
compileUnit.Namespaces.Add(rn);
this._compileUnit = compileUnit;
return(this._hasGenerated = true);
}
private void OnAddCommand()
{
var wrapper = new ProgrammingLanguageWrapper(new ProgrammingLanguage()); //utwórz nowy element, wrapper+model
wrapper.PropertyChanged += Wrapper_PropertyChanged; //podłącz eventy
_repository.Add(wrapper.Model); // dodaj nowy element do repo
ProgrammingLanguages.Add(wrapper); //dodaj do listy
wrapper.Name = ""; // tacznij triger walidacji
}
void OnAddExecute()
{
var wrapper = new ProgrammingLanguageWrapper(new Domain.ProgrammingLanguage());
wrapper.PropertyChanged += Wrapper_PropertyChanged;
_programmingLanguageRepository.Add(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
wrapper.Name = ""; // Trigger the validation
}
public void TemplateSourceConfigTest_ResolveFile()
{
var configFile = Path.GetFullPath(@".\Packaging\SampleConfig.json");
var config = TemplatesSourceConfig.LoadFromFile(configFile);
var package = config.ResolvePackage(new Version(1, 3), Platforms.Uwp, ProgrammingLanguages.GetShortProgrammingLanguage(ProgrammingLanguages.CSharp));
Assert.Equal("UWP.CS.Templates_1.2.3.4.mstx", package.Name);
}
private void OnAddExecute()
{
var wrapper = new ProgrammingLanguageWrapper(new ProgrammingLanguage());
wrapper.PropertyChanged += Wrapper_PropertyChanged;
_programmingLanguageRepository.Add(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
wrapper.Name = ""; //validation trick
}
private void OnAddExecute()
{
var wrapper = new ProgrammingLanguageWrapper(new ProgrammingLanguage());
wrapper.PropertyChanged += HandleOnWrapperPropertyChanged;
_programmingLanguageRepository.Add(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
//Trigger validation
wrapper.Name = "";
}
private async void OnAddProgramminLanguageExecute()
{
var wrapper = new ProgrammingLanguageModelWrapper(new Data.Models.ProgrammingLanguage());
wrapper.PropertyChanged += Wrapper_PropertyChanged;
await this._programmingLanguagesService.AddAsync(wrapper.Model);
ProgrammingLanguages.Add(wrapper);
wrapper.Name = "";
}
private async Task LoadProgrammingLanguagesLookupAsync()
{
ProgrammingLanguages.Clear();
ProgrammingLanguages.Add(new NullLookupItem());
var lookup = await _programmingLanguageLookupDataService.GetProgrammingLanguageLookupAsync();
foreach (var item in lookup)
{
ProgrammingLanguages.Add(item);
}
}
public SolutionObject(Int32 ProblemID, Int32 SolutionID,
ProgrammingLanguages PL, TournamentFormats TF, ProblemTypes PT,
string RelativePathToFile, string FileName)
{
this.ProblemID = ProblemID;
this.SolutionID = SolutionID;
this.PL = PL;
this.TF = TF;
this.PT = PT;
this.RelativePathToFile = RelativePathToFile;
this.FileName = FileName;
}
public static IEnumerable <object[]> GetProjectTemplates(string frameworkFilter, string programmingLanguage, string selectedPlatform)
{
InitializeTemplates(new LocalTemplatesSource(ShortFrameworkName(frameworkFilter)));
List <object[]> result = new List <object[]>();
var languagesOfInterest = ProgrammingLanguages.GetAllLanguages().ToList();
if (!string.IsNullOrWhiteSpace(programmingLanguage))
{
languagesOfInterest.Clear();
languagesOfInterest.Add(programmingLanguage);
}
var platformsOfInterest = Platforms.GetAllPlatforms().ToList();
if (!string.IsNullOrWhiteSpace(selectedPlatform))
{
platformsOfInterest.Clear();
platformsOfInterest.Add(selectedPlatform);
}
foreach (var language in languagesOfInterest)
{
SetCurrentLanguage(language);
foreach (var platform in platformsOfInterest)
{
SetCurrentPlatform(platform);
var templateProjectTypes = GenComposer.GetSupportedProjectTypes(platform);
var projectTypes = GenContext.ToolBox.Repo.GetProjectTypes(platform)
.Where(m => templateProjectTypes.Contains(m.Name) && !string.IsNullOrEmpty(m.Description))
.Select(m => m.Name);
foreach (var projectType in projectTypes)
{
var projectFrameworks = GenComposer.GetSupportedFx(projectType, platform);
var targetFrameworks = GenContext.ToolBox.Repo.GetFrameworks(platform)
.Where(m => projectFrameworks.Contains(m.Name) && m.Name == frameworkFilter)
.Select(m => m.Name)
.ToList();
foreach (var framework in targetFrameworks)
{
result.Add(new object[] { projectType, framework, platform, language });
}
}
}
}
return(result);
}
public static void AddLanguage(ProgrammingLanguages PL)
{
lock (lockObj)
{
if (!AvailableLanguages.Contains(PL))
{
availableLanguages.Add(new ProgrammingLanguage(PL, 1));
}
else
{
availableLanguages.First(l => l.PL == PL).Count++;
}
}
}
public void Test(Int32 ProblemID, Int32 SolutionID, string SolutionName,
ProgrammingLanguages PL, TournamentFormats TF, ProblemTypes PT,
out TestResults Result, out int Score, out List<Tuple<long, long, TestResults>> testResults)
{
CanTest.Wait();
AllDone.Reset();
Interlocked.Increment(ref threadCount);
logger.Debug("Start {0} thread", threadCount);
if (logger.IsDebugEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Start {0} thread", threadCount);
// TODO: FL
Result = TestResults.RTE;
Score = 0;
testResults = null;
logger.Trace("Start testing solution {0}", SolutionID);
if (logger.IsTraceEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Start testing solution {0}", SolutionID);
try
{
switch (PT)
{
case ProblemTypes.Standart:
TestStandart(ProblemID, SolutionID, SolutionName, PL, TF, out Result, out Score, out testResults);
break;
case ProblemTypes.Open:
TestOpen(ProblemID, SolutionID, SolutionName, PL, TF, out Result, out Score);
break;
}
}
catch (Exception ex)
{
logger.Error("Error occurred on solution {0} testing: {1}", SolutionID, ex.Message);
Console.WriteLine(DateTime.Now.ToString(culture) + " - Error occurred on solution {0} testing: {1}", SolutionID, ex.Message);
}
Interlocked.Decrement(ref threadCount);
if (threadCount == 0)
AllDone.Set();
}
private bool ContainsUntrustedCode(string SourceFile, ProgrammingLanguages PL, out string UntrustedCode)
{
// TODO: Add lexical analyzer
bool result = false;
UntrustedCode = String.Empty;
//return result;
switch (PL)
{
case ProgrammingLanguages.C:
result = ContainsUntrustedCodeC(SourceFile, out UntrustedCode);
break;
case ProgrammingLanguages.CPP:
result = ContainsUntrustedCodeCPP(SourceFile, out UntrustedCode);
break;
case ProgrammingLanguages.Pascal:
result = ContainsUntrustedCodePascal(SourceFile, out UntrustedCode);
break;
case ProgrammingLanguages.CS:
result = ContainsUntrustedCodeCS(SourceFile, out UntrustedCode);
break;
case ProgrammingLanguages.VB:
result = ContainsUntrustedCodeVB(SourceFile, out UntrustedCode);
break;
case ProgrammingLanguages.Java:
result = ContainsUntrustedCodeJava(SourceFile, out UntrustedCode);
break;
}
return result;
}
private void CompilePascal(string SourceFile, string OutputFile, ProgrammingLanguages PL, string WorkingDirectory = null)
{
if (PL != ProgrammingLanguages.Pascal &&
PL != ProgrammingLanguages.Delphi &&
PL != ProgrammingLanguages.ObjPas &&
PL != ProgrammingLanguages.TurboPas)
throw new NotSupportedException();
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.UseShellExecute = false;
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardOutput = true;
startInfo.FileName = Compilers.GetPath(PL);
startInfo.Arguments = Compilers.GetOptions(PL) + " \"" + SourceFile + "\" -o\"" + OutputFile + "\"";
startInfo.CreateNoWindow = true;
if (WorkingDirectory != null)
startInfo.WorkingDirectory = WorkingDirectory;
string error = "";
using (Process proc = Process.Start(startInfo))
{
error += proc.StandardError.ReadToEnd();
error += proc.StandardOutput.ReadToEnd();
proc.WaitForExit();
logger.Debug("Compilation of file \"{0}\" end", Path.GetFileName(SourceFile));
if (logger.IsDebugEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Compilation of file \"{0}\" end", Path.GetFileName(SourceFile));
if (proc.ExitCode != 0)
{
throw new InvalidDataException(error);
}
}
}
public static void RemoveLanguage(ProgrammingLanguages PL)
{
lock (lockObj)
{
if (AvailableLanguages.Contains(PL))
{
ProgrammingLanguage pl = availableLanguages.First(l => l.PL == PL);
pl.Count--;
if (pl.Count == 0)
{
availableLanguages.Remove(pl);
}
}
}
}
public SolutionObject(Int32 ProblemID, Int32 SolutionID,
ProgrammingLanguages PL, TournamentFormats TF, ProblemTypes PT,
string RelativePathToFile, string FileName)
{
this.ProblemID = ProblemID;
this.SolutionID = SolutionID;
this.PL = PL;
this.TF = TF;
this.PT = PT;
this.RelativePathToFile = RelativePathToFile;
this.FileName = FileName;
}
/// <summary>
/// Add solution for checking
/// </summary>
public void AddSolutionForChecking(Int32 problemID, Int32 solutionID,
ProgrammingLanguages PL, TournamentFormats TF, ProblemTypes PT,
string relativePathToFile, string fileName)
{
lock (this._lockSolutionsQueue)
{
_solutionsQueue.Enqueue(new SolutionObject(problemID, solutionID, PL, TF, PT, relativePathToFile, fileName));
_solutionAdded.Set();
_logger.Info("Solution " + solutionID + " for problem " + problemID + " on PL " + PL + " added to queue");
}
}
private static void SaveSolution(byte[] Data,
out int ProblemID,
out int SolutionID,
out string FileName,
out ProgrammingLanguages PL,
out TournamentFormats TF,
out ProblemTypes PT)
{
ProblemID = BitConverter.ToInt32(Data, 8);
SolutionID = BitConverter.ToInt32(Data, 12);
PL = (ProgrammingLanguages)BitConverter.ToInt32(Data, 16);
TF = (TournamentFormats)BitConverter.ToInt32(Data, 20);
PT = (ProblemTypes)BitConverter.ToInt32(Data, 24);
Int32 FileNameLength = BitConverter.ToInt32(Data, 28);
FileName = Encoding.ASCII.GetString(Data, 32, FileNameLength);
try
{
if (!Directory.Exists(LocalPath.SolutionsDirectory))
{
Directory.CreateDirectory(LocalPath.SolutionsDirectory);
}
if (Directory.Exists(LocalPath.SolutionsDirectory + SolutionID.ToString()))
{
Directory.Delete(LocalPath.SolutionsDirectory + SolutionID.ToString(), true);
}
Directory.CreateDirectory(LocalPath.SolutionsDirectory + SolutionID.ToString());
using (BinaryWriter bw = new BinaryWriter(
File.Open(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\" + FileName, FileMode.Create)))
{
bw.Write(Data, FileNameLength + 32, Data.Length - FileNameLength - 32);
}
logger.Trace("Solution {0} saved", SolutionID);
if (logger.IsTraceEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Solution {0} saved", SolutionID);
}
catch (Exception ex)
{
logger.Error("Error occurred on solution {0} saving: {1}", SolutionID, ex.Message);
Console.WriteLine(DateTime.Now.ToString(culture) + " - Error occurred on solution {0} saving: {1}", SolutionID, ex.Message);
}
}
public ProgrammingLanguage(ProgrammingLanguages PL, int Count)
{
this.PL = PL;
this.Count = Count;
}
/// <summary>
/// Send information about solution to client.
/// </summary>
public void SendSolutionFile(Int32 problemID, Int32 solutionID,
ProgrammingLanguages PL, TournamentFormats TF, ProblemTypes PT,
string relativePathToFile, string fileName)
{
_canSendRequest.Wait();
ClientFreeThreadsCount--;
string absolutePath = Path.Combine(LocalPath.RootDirectory, relativePathToFile);
if (!File.Exists(absolutePath))
{
throw new FileNotFoundException(absolutePath);
}
string extension = Path.GetExtension(fileName);
if (extension == "")
{
switch (PL)
{
case ProgrammingLanguages.C:
extension = ".c";
break;
case ProgrammingLanguages.CPP:
extension = ".cpp";
break;
case ProgrammingLanguages.CS:
extension = ".cs";
break;
case ProgrammingLanguages.Pascal:
extension = ".pas";
break;
case ProgrammingLanguages.Python:
extension = ".py";
break;
case ProgrammingLanguages.VB:
extension = ".vb";
break;
default:
_logger.Warn("Send solution " + solutionID + " file without extension");
break;
}
}
string fName = PL == ProgrammingLanguages.Java ? fileName : solutionID.ToString() + extension;
byte[] name = Encoding.ASCII.GetBytes(fName);
byte[] fileData = File.ReadAllBytes(absolutePath);
byte[] clientData = new byte[4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + name.Length + fileData.Length];
byte[] fileNameLen = BitConverter.GetBytes(name.Length);
BitConverter.GetBytes(clientData.Length).CopyTo(clientData, 0);
BitConverter.GetBytes((Int32)RequestCodes.SolutionFile).CopyTo(clientData, 4);
BitConverter.GetBytes(problemID).CopyTo(clientData, 8);
BitConverter.GetBytes(solutionID).CopyTo(clientData, 12);
BitConverter.GetBytes((Int32)PL).CopyTo(clientData, 16);
BitConverter.GetBytes((Int32)TF).CopyTo(clientData, 20);
BitConverter.GetBytes((Int32)PT).CopyTo(clientData, 24);
fileNameLen.CopyTo(clientData, 28);
name.CopyTo(clientData, 32);
fileData.CopyTo(clientData, 32 + name.Length);
Send(clientData, clientData.Length);
_logger.Debug(Address + ": Send solution " + solutionID + " file");
}
public void TestStandart(Int32 ProblemID, Int32 SolutionID, string SolutionName,
ProgrammingLanguages PL, TournamentFormats TF,
out TestResults Result, out int Score, out List<Tuple<long, long, TestResults>> TestResults)
{
// TODO: FL
Result = Solomon.TypesExtensions.TestResults.RTE;
TestResults = null;
Score = 0;
File.Copy(LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\checker.exe",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe", true);
DirectoryExtensions.Copy(LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\Tests",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\Tests", false);
if (!Directory.Exists(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe"))
{
Directory.CreateDirectory(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe");
}
if (!Directory.Exists(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output"))
{
Directory.CreateDirectory(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output");
}
CompilerSingleton.Instance.Compile(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\" + SolutionName,
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe\\" + SolutionName + ".exe", PL, out Result, SolutionID);
if (Result != Solomon.TypesExtensions.TestResults.OK)
{
//Interlocked.Decrement(ref threadCount);
return;
}
// Testing
// TODO: FL
Result = Solomon.TypesExtensions.TestResults.RTE;
TestResults = new List<Tuple<long, long, TestResults>>();
Tuple<long, long, TestResults> tempTuple;
// Get all "in" files
String[] inFiles = null;
inFiles = Directory.GetFiles(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\Tests", "*.in");
double timeLimit;
int memoryLimit;
string name;
long solutionTime, solutionMemory;
DateTime lastModifiedTime;
ProblemLegend.Read(LocalPath.ProblemsDirectory + ProblemID.ToString(),
out name, out timeLimit, out memoryLimit, out lastModifiedTime);
int testOK = 0;
foreach (String inFile in inFiles)
{
solutionTime = 0;
solutionMemory = 0;
try
{
if (PL == ProgrammingLanguages.Java)
{
RunSolutionClass(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe\\" + SolutionName,
inFile,
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt",
timeLimit, memoryLimit, out Result, out solutionTime, out solutionMemory);
}
else if (PL == ProgrammingLanguages.Python)
{
RunSolutionPython(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe\\" + SolutionName,
inFile,
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt",
timeLimit, memoryLimit, out Result, out solutionTime, out solutionMemory);
}
else
{
RunSolutionExe(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\exe\\" + SolutionName + ".exe",
inFile,
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt",
timeLimit, memoryLimit, out Result, out solutionTime, out solutionMemory);
}
}
catch (Exception ex)
{
logger.Error("Warning on solution {0} running: {1}", SolutionID, ex.Message);
Console.WriteLine(DateTime.Now.ToString(culture) + " - Warning on solution {0} running: {1}", SolutionID, ex.Message);
}
if (Result != Solomon.TypesExtensions.TestResults.OK)
{
tempTuple = new Tuple<long, long, TestResults>(solutionTime, solutionMemory, Result);
TestResults.Add(tempTuple);
if (TF == TournamentFormats.ACM)
break;
else
continue;
}
Result = Solomon.TypesExtensions.TestResults.Executing;
for (int i = 0; i < 5 && (int)Result >= 4; i++)
{
CheckSolutionOutput(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe",
inFile,
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\Tests\\" + Path.GetFileNameWithoutExtension(inFile) + ".out",
out Result);
}
tempTuple = new Tuple<long, long, TestResults>(solutionTime, solutionMemory, Result);
TestResults.Add(tempTuple);
if (Result != Solomon.TypesExtensions.TestResults.OK)
{
if (TF == TournamentFormats.ACM)
break;
}
else
{
testOK++;
}
}
if (TF == TournamentFormats.IOI)
{
Score = 100 * testOK / inFiles.Length;
Result = testOK == inFiles.Length ? Solomon.TypesExtensions.TestResults.OK : Solomon.TypesExtensions.TestResults.PS;
}
if (File.Exists(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt"))
File.Delete(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\output\\output.txt");
for (int i = 0; i < 5; i++)
{
try
{
Directory.Delete(LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\Tests", true);
break;
}
catch (Exception) { Thread.Sleep(100); }
}
}
public void Compile(string SourceFile, string OutputFile, ProgrammingLanguages PL, out TestResults Result, int SolutionID = -1, string WorkingDirectory = null)
{
if (!AvailablePL.Contains(PL))
{
throw new NotSupportedException("Compiler " + PL.ToString() + " not supported");
}
if (PL != ProgrammingLanguages.Python)
{
logger.Debug("Begin compiling solution {0} \"{1}\"", SolutionID, Path.GetFileName(SourceFile));
if (logger.IsDebugEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Begin compiling solution {0} \"{1}\"", SolutionID, Path.GetFileName(SourceFile));
}
if (File.Exists(OutputFile))
{
File.Delete(OutputFile);
}
string untrustedCode;
if (ContainsUntrustedCode(SourceFile, PL, out untrustedCode))
{
logger.Debug("Solution {0} \"{1}\" contains untrusted code: {2}", SolutionID, Path.GetFileName(SourceFile), untrustedCode);
if (logger.IsDebugEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Solution {0} \"{1}\" contains untrusted code: {2}", SolutionID, Path.GetFileName(SourceFile), untrustedCode);
Result = TestResults.CE;
return;
}
// TODO: FL
Result = TestResults.RTE;
try
{
switch (PL)
{
case ProgrammingLanguages.C:
CompileC(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.CPP:
CompileCPP(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.VCPP:
CompileCPP(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.CS:
CompileCS(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.VB:
CompileVB(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.Java:
CompileJava(SourceFile, OutputFile, WorkingDirectory);
break;
case ProgrammingLanguages.Pascal:
case ProgrammingLanguages.Delphi:
case ProgrammingLanguages.ObjPas:
case ProgrammingLanguages.TurboPas:
CompilePascal(SourceFile, OutputFile, PL, WorkingDirectory);
break;
case ProgrammingLanguages.Python:
CompilePython(SourceFile, OutputFile, WorkingDirectory);
break;
default:
throw new NotSupportedException("Compiler not found in case");
}
}
catch (InvalidDataException ex)
{
logger.Debug("Compiling solution {0} \"{1}\" fail: {2}", SolutionID, Path.GetFileName(SourceFile), ex.Message);
if (logger.IsDebugEnabled)
Console.WriteLine(DateTime.Now.ToString(culture) + " - Compiling solution {0} \"{1}\" fail: {2}", SolutionID, Path.GetFileName(SourceFile), ex.Message);
Result = TestResults.CE;
return;
}
Result = TestResults.OK;
}
public void TestOpen(Int32 ProblemID, Int32 SolutionID, string SolutionName,
ProgrammingLanguages PL, TournamentFormats TF,
out TestResults Result, out int Score)
{
// TODO: FL
Result = TestResults.RTE;
Score = 0;
File.Copy(LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\checker.exe",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe", true);
// Test
CheckSolutionOutput(
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\checker.exe",
LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\OpenProblemResult",
LocalPath.SolutionsDirectory + SolutionID.ToString() + "\\" + SolutionName,
LocalPath.ProblemsDirectory + ProblemID.ToString() + "\\OpenProblemResult",
out Result);
if (Result == TestResults.OK)
{
Score = 100;
}
}
