trackler 2.2.1.151 → 2.2.1.152

data/tracks/delphi/exercises/grade-school/uGradeSchoolTest.pas

@@ -0,0 +1,150 @@
+unit uGradeSchoolTest;
+
+interface
+uses
+  DUnitX.TestFramework, uGradeSchool;
+
+const
+  CanonicalVersion = '1.0.0';
+
+type
+  [TestFixture]
+  GradeSchoolTest = class(TObject)
+  private        {ISchool and TRoster are types to be declared in the student's solution}
+    school: ISchool;
+    actual: TRoster;
+    expected: TRoster;
+    procedure CompareTwoArrays<T>(Array1, Array2: array of T);
+  public
+    [Setup]
+    procedure Setup; //Is called before each test is performed
+
+    [TearDown]
+    procedure TearDown; //Is called immediately at the conclusion of each test
+
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure Adding_a_student_adds_them_to_the_sorted_roster;
+
+    [Test]
+    [Ignore]
+    procedure Adding_more_student_adds_them_to_the_sorted_roster;
+
+    [Test]
+    [Ignore]
+    procedure Adding_students_to_different_grades_adds_them_to_the_same_sorted_roster;
+
+    [Test]
+    [Ignore]
+    procedure Grade_returns_the_students_in_that_grade_in_alphabetical_order;
+
+    [Test]
+    [Ignore]
+    procedure Grade_returns_an_empty_list_if_there_are_no_students_in_that_grade;
+
+    [Test]
+    [Ignore]
+    procedure Roster_returns_an_empty_list_if_there_are_no_students_enrolled;
+
+    [Test]
+    [Ignore]
+    procedure Student_names_with_grades_are_displayed_in_the_same_sorted_roster;
+  end;
+
+implementation
+
+{ GradeSchoolTest }
+
+procedure GradeSchoolTest.CompareTwoArrays<T>(Array1, Array2: array of T);
+var
+  I: integer;
+begin
+  Assert.AreEqual(length(Array1), length(Array2));
+  for I := Low(Array1) to High(Array1) do
+    Assert.AreEqual(Array1[I], Array2[I]);
+end;
+
+procedure GradeSchoolTest.Adding_a_student_adds_them_to_the_sorted_roster;
+begin
+  school.Add('Aimee', 2);
+  actual := school.Roster;
+  expected.Add('Aimee');
+
+  CompareTwoArrays<string>(expected.ToArray, actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Adding_more_student_adds_them_to_the_sorted_roster;
+begin
+  school.Add('Blair', 2);
+  school.Add('James', 2);
+  school.Add('Paul', 2);
+  actual := school.Roster;
+  expected.AddRange(['Blair','James','Paul']);
+
+  CompareTwoArrays<string>(expected.ToArray, actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Adding_students_to_different_grades_adds_them_to_the_same_sorted_roster;
+begin
+  school.Add('Chelsea', 3);
+  school.Add('Logan', 7);
+  actual := school.Roster;
+  expected.AddRange(['Chelsea','Logan']);
+
+  CompareTwoArrays<string>(expected.ToArray, actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Grade_returns_an_empty_list_if_there_are_no_students_in_that_grade;
+begin
+  actual := school.Grade(1);
+  Assert.IsEmpty(actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Grade_returns_the_students_in_that_grade_in_alphabetical_order;
+begin
+  school.Add('Franklin', 5);
+  school.Add('Bradley', 5);
+  school.Add('Jeff', 1);
+  actual := school.Grade(5);
+  expected.AddRange(['Bradley','Franklin']);
+
+  CompareTwoArrays<string>(expected.ToArray, actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Roster_returns_an_empty_list_if_there_are_no_students_enrolled;
+begin
+  actual := school.Roster;
+  Assert.IsEmpty(actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Student_names_with_grades_are_displayed_in_the_same_sorted_roster;
+begin
+  school.Add('Peter', 2);
+  school.Add('Anna', 1);
+  school.Add('Barb', 1);
+  school.Add('Zoe', 2);
+  school.Add('Alex', 2);
+  school.Add('Jim', 3);
+  school.Add('Charlie', 1);
+  actual := school.Roster;
+  expected.AddRange(['Anna', 'Barb', 'Charlie', 'Alex', 'Peter', 'Zoe', 'Jim']);
+
+  CompareTwoArrays<string>(expected.ToArray, actual.ToArray);
+end;
+
+procedure GradeSchoolTest.Setup;
+begin
+  school := NewSchool;
+  expected := TRoster.Create;
+end;
+
+procedure GradeSchoolTest.TearDown;
+begin
+  actual.DisposeOf;
+  expected.DisposeOf;
+  school := nil;
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(GradeSchoolTest);
+end.

data/tracks/delphi/exercises/hamming/README.md

@@ -31,9 +31,10 @@ The Hamming distance between these two DNA strands is 7.
 
 # Implementation notes
 
-The Hamming distance is only defined for sequences of equal length. This means
-that based on the definition, each language could deal with getting sequences
-of equal length differently.
+The Hamming distance is only defined for sequences of equal length, so
+an attempt to calculate it between sequences of different lengths should
+not work. The general handling of this situation (e.g., raising an
+exception vs returning a special value) may differ between languages.
 
 ## Testing
 

data/tracks/delphi/exercises/proverb/Proverb.dpr

@@ -0,0 +1,60 @@
+program Proverb;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uProverbTests in 'uProverbTests.pas',
+  uProverb in 'uProverb.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := True; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.

data/tracks/delphi/exercises/proverb/README.md

@@ -0,0 +1,44 @@
+# Proverb
+
+For want of a horseshoe nail, a kingdom was lost, or so the saying goes.
+
+Given a list of inputs, generate the relevant proverb. For example, given the list `["nail", "shoe", "horse", "rider", "message", "battle", "kingdom"]`, you will output the full text of this proverbial rhyme:
+
+```text
+For want of a nail the shoe was lost.
+For want of a shoe the horse was lost.
+For want of a horse the rider was lost.
+For want of a rider the message was lost.
+For want of a message the battle was lost.
+For want of a battle the kingdom was lost.
+And all for the want of a nail.
+```
+
+Note that the list of inputs may vary; your solution should be able to handle lists of arbitrary length and content. No line of the output text should be a static, unchanging string; all should vary according to the input given.
+
+## Testing
+
+In order to run the tests for this track, you will need to install
+DUnitX. Please see the [installation](http://www.exercism.io/languages/delphi/installation) instructions for more information.
+
+### Loading Exercises into Delphi
+
+If Delphi is properly installed, and `*.dpr` file types have been associated with Delphi, then double clicking the supplied `*.dpr` file will start Delphi and load the exercise/project.  `control + F9` is the keyboard shortcut to compile the project or pressing `F9` will compile and run the project.
+
+Alternatively you may opt to start Delphi and load your project via. the `File` drop down menu.
+
+### When Questions Come Up
+We monitor the [Pascal-Delphi](https://gitter.im/exercism/Pascal-Delphi) support room on [gitter.im](https://gitter.im) to help you with any questions that might arise.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the exercise file you're submitting is in the `exercism/delphi/<exerciseName>` directory.
+
+For example, if you're submitting `ubob.pas` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/delphi/bob/ubob.pas`.
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/For_Want_of_a_Nail](http://en.wikipedia.org/wiki/For_Want_of_a_Nail)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/proverb/uProverbExample.pas

@@ -0,0 +1,60 @@
+unit uProverb;
+
+interface
+
+type
+  IProverb = interface(IInterface)
+  ['{98C2D34D-1073-4E6D-B548-689745C22D2D}']
+    function recite: TArray<string>;
+  end;
+
+
+function Proverb(aPieces: array of string): IProverb;
+
+implementation
+uses SysUtils;
+
+type
+  TProverb = class(TInterfacedObject, IProverb)
+  private
+    fPieces: Array of string;
+  public
+    constructor create(aPieces: array of string);
+    function recite: TArray<string>;
+  end;
+
+function Proverb(aPieces: array of string): IProverb;
+begin
+  result := TProverb.create(aPieces);
+end;
+
+{ TProverb }
+
+constructor TProverb.create(aPieces: array of string);
+var
+  i: integer;
+begin
+  SetLength(fPieces, length(aPieces));
+  if length(aPieces) > 0 then
+    for i := Low(aPieces) to High(aPieces) do
+      fPieces[i] := aPieces[i];
+end;
+
+function TProverb.recite: TArray<string>;
+var
+  lineIndex: integer;
+  lengthPieces: integer;
+begin
+  lengthPieces := Length(fPieces);
+  SetLength(result, lengthPieces);
+  if lengthPieces > 0 then
+    for lineIndex := 1 to lengthPieces do
+    begin
+      if lineIndex = lengthPieces then
+        result[lineIndex-1] := format('And all for the want of a %s.',[fPieces[Low(fPieces)]])
+      else
+        result[lineIndex-1] := format('For want of a %s the %s was lost.',[fPieces[lineIndex - 1], fPieces[lineIndex]]);
+    end;
+end;
+
+end.

data/tracks/delphi/exercises/proverb/uProverbTests.pas

@@ -0,0 +1,124 @@
+unit uProverbTests;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+const
+  CanonicalVersion = '1.1.0';
+
+type
+
+  [TestFixture]
+  ProverbTest = class(TObject)
+  private
+    procedure CompareExpectedAndActual(aExpected, aActual: array of string);
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure zero_pieces;
+
+    [Test]
+    [Ignore]
+    procedure one_piece;
+
+    [Test]
+    [Ignore]
+    procedure two_pieces;
+
+    [Test]
+    [Ignore]
+    procedure three_pieces;
+
+    [Test]
+    [Ignore]
+    procedure full_proverb;
+
+    [Test]
+    [Ignore]
+    procedure four_pieces_modernized;
+  end;
+
+implementation
+uses uProverb;
+
+{ ProverbTest }
+
+procedure ProverbTest.CompareExpectedAndActual(aExpected,
+  aActual: array of string);
+var
+  i: integer;
+begin
+  Assert.AreEqual(length(aExpected), length(aActual));
+  for i := Low(aExpected) to High(aExpected) do
+    Assert.AreEqual(aExpected[i], aActual[i]);
+end;
+
+procedure ProverbTest.four_pieces_modernized;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 4);
+  Expected [0] := 'For want of a pin the gun was lost.';
+  Expected [1] := 'For want of a gun the soldier was lost.';
+  Expected [2] := 'For want of a soldier the battle was lost.';
+  Expected [3] := 'And all for the want of a pin.';
+  CompareExpectedAndActual(Expected, Proverb(['pin','gun','soldier','battle']).recite);
+end;
+
+procedure ProverbTest.full_proverb;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 7);
+  Expected[0] := 'For want of a nail the shoe was lost.';
+  Expected[1] := 'For want of a shoe the horse was lost.';
+  Expected[2] := 'For want of a horse the rider was lost.';
+  Expected[3] := 'For want of a rider the message was lost.';
+  Expected[4] := 'For want of a message the battle was lost.';
+  Expected[5] := 'For want of a battle the kingdom was lost.';
+  Expected[6] := 'And all for the want of a nail.';
+  CompareExpectedAndActual(Expected, Proverb(['nail','shoe','horse','rider','message','battle','kingdom']).recite);
+end;
+
+procedure ProverbTest.one_piece;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'And all for the want of a nail.';
+  CompareExpectedAndActual(Expected, Proverb(['nail']).recite);
+end;
+
+procedure ProverbTest.three_pieces;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 3);
+  Expected[0] := 'For want of a nail the shoe was lost.';
+  Expected[1] := 'For want of a shoe the horse was lost.';
+  Expected[2] := 'And all for the want of a nail.';
+  CompareExpectedAndActual(Expected, Proverb(['nail','shoe','horse']).recite);
+end;
+
+procedure ProverbTest.two_pieces;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 2);
+  Expected[0] := 'For want of a nail the shoe was lost.';
+  Expected[1] := 'And all for the want of a nail.';
+  CompareExpectedAndActual(Expected, Proverb(['nail','shoe']).recite);
+end;
+
+procedure ProverbTest.zero_pieces;
+var
+  Expected: Array of string;
+begin
+  SetLength(Expected, 0);
+  CompareExpectedAndActual(Expected, Proverb([]).recite);
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(ProverbTest);
+end.