.NET port

.github/workflows/csharp-ci.yml

@@ -0,0 +1,29 @@
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - 'dotnet/**'
+defaults:
+  run:
+    working-directory: dotnet
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        jre: [11]
+        os: [ubuntu-latest, windows-latest]
+        dotnet-version: ['6.0.x']
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+      - run: dotnet format --verify-no-changes ./Selfie.sln
+      - run: dotnet build
+      - run: dotnet test

.gitignore

@@ -3,4 +3,5 @@
 build/
 bin/
 .DS_Store
-__pycache__/
+__pycache__/
+obj/

dotnet/.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.cs]
+csharp_style_namespace_declarations = file_scoped:error
+csharp_style_var_for_built_in_types = false:suggestion
+csharp_style_var_when_type_is_apparent = false:suggestion
+csharp_style_var_elsewhere = false:suggestion
+csharp_new_line_before_open_brace = none

dotnet/Selfie.Lib.Tests/ArrayMapTest.cs

@@ -0,0 +1,104 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DiffPlug.Selfie.Lib.Tests;
+
+[TestFixture]
+public class ArrayMapTest {
+  [Test]
+  public void Empty() {
+    var empty = ArrayMap<string, string>.Empty;
+    AssertEmpty(empty);
+  }
+
+  [Test]
+  public void Single() {
+    var empty = ArrayMap<string, string>.Empty;
+    var single = empty.Plus("one", "1");
+    AssertEmpty(empty);
+    AssertSingle(single, "one", "1");
+  }
+
+  [Test]
+  public void Double() {
+    var empty = ArrayMap<string, string>.Empty;
+    var single = empty.Plus("one", "1");
+    var doubleMap = single.Plus("two", "2");
+    AssertEmpty(empty);
+    AssertSingle(single, "one", "1");
+    AssertDouble(doubleMap, "one", "1", "two", "2");
+    // ensure sorted also
+    AssertDouble(single.Plus("a", "sorted"), "a", "sorted", "one", "1");
+
+    var ex = Assert.Throws<ArgumentException>(() => single.Plus("one", "2"));
+    Assert.That(ex.Message, Is.EqualTo("Key already exists: one"));
+  }
+
+  // [Test]
+  // public void Of() {
+  //   AssertEmpty(ArrayMap<string, string>.Of());
+  //   AssertSingle(ArrayMap<string, string>.Of(new KeyValuePair<string, string>("one", "1") });
+  //   AssertDouble(ArrayMap<string, string>.Of(new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>("one", "1"), new KeyValuePair<string, string>("two", "2") }), "one", "1", "two", "2");
+  //   AssertDouble(ArrayMap<string, string>.Of(new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>("two", "2"), new KeyValuePair<string, string>("one", "1") }), "one", "1", "two", "2");
+  // }
+
+  // [Test]
+  // public void Multi() {
+  //   AssertTriple(
+  //       ArrayMap.Empty<string, string>().Plus("1", "one").Plus("2", "two").Plus("3", "three"),
+  //       "1", "one", "2", "two", "3", "three");
+  //   AssertTriple(
+  //       ArrayMap.Empty<string, string>().Plus("2", "two").Plus("3", "three").Plus("1", "one"),
+  //       "1", "one", "2", "two", "3", "three");
+  //   AssertTriple(
+  //       ArrayMap.Empty<string, string>().Plus("3", "three").Plus("1", "one").Plus("2", "two"),
+  //       "1", "one", "2", "two", "3", "three");
+  // }
+
+  private void AssertEmpty(IDictionary<string, string> map) {
+    Assert.That(map.Count, Is.EqualTo(0));
+    Assert.IsFalse(map.Keys.Any());
+    Assert.IsFalse(map.Values.Any());
+    Assert.IsFalse(map.ContainsKey("key"));
+    Assert.That(map.FirstOrDefault().Value, Is.EqualTo(default(string)));
+  }
+
+  private void AssertSingle(IDictionary<string, string> map, string key, string value) {
+    Assert.That(map.Count, Is.EqualTo(1));
+    Assert.IsTrue(map.ContainsKey(key));
+    Assert.That(map[key], Is.EqualTo(value));
+    var singleEntry = new KeyValuePair<string, string>(key, value);
+    Assert.IsTrue(map.Contains(singleEntry));
+  }
+
+  private void AssertDouble(IDictionary<string, string> map, string key1, string value1, string key2, string value2) {
+    Assert.That(map.Count, Is.EqualTo(2));
+    Assert.IsTrue(map.ContainsKey(key1));
+    Assert.IsTrue(map.ContainsKey(key2));
+    Assert.That(map[key1], Is.EqualTo(value1));
+    Assert.That(map[key2], Is.EqualTo(value2));
+    var entry1 = new KeyValuePair<string, string>(key1, value1);
+    var entry2 = new KeyValuePair<string, string>(key2, value2);
+    Assert.IsTrue(map.Contains(entry1));
+    Assert.IsTrue(map.Contains(entry2));
+  }
+
+  private void AssertTriple(IDictionary<string, string> map, string key1, string value1, string key2, string value2, string key3, string value3) {
+    Assert.That(map.Count, Is.EqualTo(3));
+    Assert.IsTrue(map.ContainsKey(key1));
+    Assert.IsTrue(map.ContainsKey(key2));
+    Assert.IsTrue(map.ContainsKey(key3));
+    Assert.That(map[key1], Is.EqualTo(value1));
+    Assert.That(map[key2], Is.EqualTo(value2));
+    Assert.That(map[key3], Is.EqualTo(value3));
+    var entry1 = new KeyValuePair<string, string>(key1, value1);
+    var entry2 = new KeyValuePair<string, string>(key2, value2);
+    var entry3 = new KeyValuePair<string, string>(key3, value3);
+    Assert.IsTrue(map.Contains(entry1));
+    Assert.IsTrue(map.Contains(entry2));
+    Assert.IsTrue(map.Contains(entry3));
+  }
+}
+

dotnet/Selfie.Lib.Tests/Selfie.Lib.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <LangVersion>11.0</LangVersion>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>DiffPlug.Selfie.Lib</RootNamespace>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Selfie.Lib\Selfie.Lib.csproj" />
+  </ItemGroup>
+</Project>

dotnet/Selfie.Lib.Tests/guts/SliceTest.cs

@@ -0,0 +1,20 @@
+using NUnit.Framework;
+
+namespace DiffPlug.Selfie.Lib.Guts.Tests;
+
+[TestFixture]
+public class SliceTest {
+  [Test]
+  public void UnixLine() {
+    var singleLine = new Slice("A single line");
+    Assert.That(singleLine.UnixLine(1).ToString(), Is.EqualTo("A single line"));
+
+    var oneTwoThree = new Slice("\nI am the first\nI, the second\n\nFOURTH\n");
+    Assert.That(oneTwoThree.UnixLine(1).ToString(), Is.EqualTo(""));
+    Assert.That(oneTwoThree.UnixLine(2).ToString(), Is.EqualTo("I am the first"));
+    Assert.That(oneTwoThree.UnixLine(3).ToString(), Is.EqualTo("I, the second"));
+    Assert.That(oneTwoThree.UnixLine(4).ToString(), Is.EqualTo(""));
+    Assert.That(oneTwoThree.UnixLine(5).ToString(), Is.EqualTo("FOURTH"));
+    Assert.That(oneTwoThree.UnixLine(6).ToString(), Is.EqualTo(""));
+  }
+}