trackler 2.2.1.74 → 2.2.1.75

data/tracks/delphi/exercises/isbn-verifier/uTestISBNVerifier.pas

@@ -0,0 +1,136 @@
+unit uTestISBNVerifier;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+type
+  [TestFixture]
+  ISBNVerifierTest = class(TObject)
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure valid_isbn_number;
+
+    [Test]
+    [Ignore]
+    procedure invalid_isbn_check_digit;
+
+    [Test]
+    [Ignore]
+    procedure valid_isbn_number_with_a_check_digit_of_10;
+
+    [Test]
+    [Ignore]
+    procedure check_digit_is_a_character_other_than_X;
+
+    [Test]
+    [Ignore]
+    procedure invalid_character_in_isbn;
+
+    [Test]
+    [Ignore]
+    procedure X_is_only_valid_as_a_check_digit;
+
+    [Test]
+    [Ignore]
+    procedure valid_isbn_without_separating_dashes;
+
+    [Test]
+    [Ignore]
+    procedure isbn_without_separating_dashes_and_X_as_check_digit;
+
+    [Test]
+    [Ignore]
+    procedure isbn_without_check_digit_and_dashes;
+
+    [Test]
+    [Ignore]
+    procedure too_long_isbn_and_no_dashes;
+
+    [Test]
+    [Ignore]
+    procedure isbn_without_check_digit;
+
+    [Test]
+    [Ignore]
+    procedure too_long_isbn;
+
+    [Test]
+    [Ignore]
+    procedure check_digit_of_X_should_not_be_used_for_0;
+  end;
+
+implementation
+uses uISBNVerifier;
+
+{ ISBNVerifierTest }
+
+procedure ISBNVerifierTest.check_digit_is_a_character_other_than_X;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-21507-A'));
+end;
+
+procedure ISBNVerifierTest.check_digit_of_X_should_not_be_used_for_0;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-21515-X'));
+end;
+
+procedure ISBNVerifierTest.invalid_character_in_isbn;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-2K507-0'))
+end;
+
+procedure ISBNVerifierTest.invalid_isbn_check_digit;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-21508-9'));
+end;
+
+procedure ISBNVerifierTest.isbn_without_check_digit;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-21507'));
+end;
+
+procedure ISBNVerifierTest.isbn_without_check_digit_and_dashes;
+begin
+  Assert.IsFalse(TIsbn.isValid('359821507'));
+end;
+
+procedure ISBNVerifierTest.isbn_without_separating_dashes_and_X_as_check_digit;
+begin
+  Assert.IsTrue(TIsbn.isValid('359821507X'));
+end;
+
+procedure ISBNVerifierTest.too_long_isbn;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-21507-XX'));
+end;
+
+procedure ISBNVerifierTest.too_long_isbn_and_no_dashes;
+begin
+  Assert.IsFalse(TIsbn.isValid('3598215078X'));
+end;
+
+procedure ISBNVerifierTest.valid_isbn_number;
+begin
+  Assert.IsTrue(TIsbn.isValid('3-598-21508-8'));
+end;
+
+procedure ISBNVerifierTest.valid_isbn_number_with_a_check_digit_of_10;
+begin
+  Assert.IsTrue(TIsbn.isValid('3-598-21507-X'));
+end;
+
+procedure ISBNVerifierTest.valid_isbn_without_separating_dashes;
+begin
+  Assert.IsTrue(TIsbn.isValid('3598215088'));
+end;
+
+procedure ISBNVerifierTest.X_is_only_valid_as_a_check_digit;
+begin
+  Assert.IsFalse(TIsbn.isValid('3-598-2X507-9'));
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(ISBNVerifierTest);
+end.

data/tracks/delphi/exercises/secret-handshake/README.md

@@ -0,0 +1,56 @@
+# Secret Handshake
+
+> There are 10 types of people in the world: Those who understand
+> binary, and those who don't.
+
+You and your fellow cohort of those in the "know" when it comes to
+binary decide to come up with a secret "handshake".
+
+```text
+1 = wink
+10 = double blink
+100 = close your eyes
+1000 = jump
+
+
+10000 = Reverse the order of the operations in the secret handshake.
+```
+
+Given a decimal number, convert it to the appropriate sequence of events for a secret handshake.
+
+Here's a couple of examples:
+
+Given the input 3, the function would return the array
+["wink", "double blink"] because 3 is 11 in binary.
+
+Given the input 19, the function would return the array
+["double blink", "wink"] because 19 is 10011 in binary.
+Notice that the addition of 16 (10000 in binary)
+has caused the array to be reversed.
+
+## 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
+
+Bert, in Mary Poppins [http://www.imdb.com/title/tt0058331/quotes/qt0437047](http://www.imdb.com/title/tt0058331/quotes/qt0437047)
+
+## 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/secret-handshake/SecretHandshake.dpr

@@ -0,0 +1,60 @@
+program SecretHandshake;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uSecretHandshake in 'uSecretHandshake.pas',
+  uTestSecretHandshake in 'uTestSecretHandshake.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 := False; //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/secret-handshake/uSecretHandshakeExample.pas

@@ -0,0 +1,56 @@
+unit uSecretHandshake;
+
+interface
+uses Generics.Collections;
+
+type
+  TSecretHandshake = class
+  private
+    class var CommandValues: TList<TPair<integer, string>>;
+    class procedure BuildCommandValues;
+    class function ShouldReverse(aCommandValue: integer): Boolean;
+  public
+    class function commands(aInput: integer): TArray<string>;
+  end;
+
+implementation
+uses SysUtils;
+
+{ TSecretHandshake }
+
+class procedure TSecretHandshake.BuildCommandValues;
+begin
+  if not assigned(CommandValues) then
+  begin
+    CommandValues := TList<TPair<integer, string>>.Create;
+    CommandValues.Add(TPair<integer,string>.Create(1, 'wink'));
+    CommandValues.Add(TPair<integer,string>.Create(2, 'double blink'));
+    CommandValues.Add(TPair<integer,string>.Create(4, 'close your eyes'));
+    CommandValues.Add(TPair<integer,string>.Create(8, 'jump'));
+  end;
+end;
+
+class function TSecretHandshake.commands(aInput: integer): TArray<string>;
+var lCommands: TList<string>;
+    lKeyValue: TPair<integer,string>;
+begin
+  BuildCommandValues;
+  lCommands := TList<string>.Create;
+
+  for lKeyValue in CommandValues do
+  begin
+    if aInput and lKeyValue.Key <> 0 then
+      lCommands.Add(lKeyValue.Value);
+  end;
+
+  if ShouldReverse(aInput) then
+    lCommands.Reverse;
+  result := lCommands.ToArray;
+end;
+
+class function TSecretHandshake.ShouldReverse(aCommandValue: integer): Boolean;
+begin
+  result := (aCommandValue and 16) <> 0;
+end;
+
+end.

data/tracks/delphi/exercises/secret-handshake/uTestSecretHandshake.pas

@@ -0,0 +1,215 @@
+unit uTestSecretHandshake;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+const
+  CanonicalVersion = '1.1.0';
+
+type
+  [TestFixture]
+  SecretHandshakeTest = class(TObject)
+  private
+    procedure CompareArrays(aExpected, aActual: TArray<string>);
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure wink_for_1;
+
+    [Test]
+    [Ignore]
+    procedure double_blink_for_10;
+
+    [Test]
+    [Ignore]
+    procedure close_your_eyes_for_100;
+
+    [Test]
+    [Ignore]
+    procedure jump_for_1000;
+
+    [Test]
+    [Ignore]
+    procedure combine_two_actions;
+
+    [Test]
+    [Ignore]
+    procedure reverse_two_actions;
+
+    [Test]
+    [Ignore]
+    procedure reversing_one_action_gives_the_same_action;
+
+    [Test]
+    [Ignore]
+    procedure reversing_no_actions_still_gives_no_actions;
+
+    [Test]
+    [Ignore]
+    procedure all_possible_actions;
+
+    [Test]
+    [Ignore]
+    procedure reverse_all_possible_actions;
+
+    [Test]
+    [Ignore]
+    procedure do_nothing_for_zero;
+  end;
+
+implementation
+uses uSecretHandshake;
+
+
+{ SecretHandshakeTest }
+
+procedure SecretHandshakeTest.all_possible_actions;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 4);
+  Expected[0] := 'wink';
+  Expected[1] := 'double blink';
+  Expected[2] := 'close your eyes';
+  Expected[3] := 'jump';
+
+  Actual := TSecretHandshake.commands(15);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.close_your_eyes_for_100;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'close your eyes';
+
+  Actual := TSecretHandshake.commands(4);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.combine_two_actions;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 2);
+  Expected[0] := 'wink';
+  Expected[1] := 'double blink';
+
+  Actual := TSecretHandshake.commands(3);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.double_blink_for_10;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'double blink';
+
+  Actual := TSecretHandshake.commands(2);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.do_nothing_for_zero;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 0);
+
+  Actual := TSecretHandshake.commands(0);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.jump_for_1000;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'jump';
+
+  Actual := TSecretHandshake.commands(8);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.reverse_all_possible_actions;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 4);
+  Expected[0] := 'jump';
+  Expected[1] := 'close your eyes';
+  Expected[2] := 'double blink';
+  Expected[3] := 'wink';
+
+  Actual := TSecretHandshake.commands(31);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.reverse_two_actions;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 2);
+  Expected[0] := 'double blink';
+  Expected[1] := 'wink';
+
+  Actual := TSecretHandshake.commands(19);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.reversing_no_actions_still_gives_no_actions;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 0);
+
+  Actual := TSecretHandshake.commands(16);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.reversing_one_action_gives_the_same_action;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'jump';
+
+  Actual := TSecretHandshake.commands(24);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.wink_for_1;
+var Expected,
+    Actual: TArray<string>;
+begin
+  SetLength(Expected, 1);
+  Expected[0] := 'wink';
+
+  Actual := TSecretHandshake.commands(1);
+
+  CompareArrays(Expected, Actual);
+end;
+
+procedure SecretHandshakeTest.CompareArrays(aExpected, aActual: TArray<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;
+
+initialization
+  TDUnitX.RegisterTestFixture(SecretHandshakeTest);
+end.