diff --git a/ortools/algorithms/csharp/KnapsackSolverTests.cs b/ortools/algorithms/csharp/KnapsackSolverTests.cs
new file mode 100644
index 0000000000..9b4cac2358
--- /dev/null
+++ b/ortools/algorithms/csharp/KnapsackSolverTests.cs
@@ -0,0 +1,114 @@
+// Copyright 2010-2022 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Xunit;
+using Google.OrTools.Algorithms;
+
+namespace Google.OrTools.Tests
+{
+public class KnapsakSolverTest
+{
+    private long RunKnapsackSolver(KnapsackSolver.SolverType solverType, long[] profits, long[,] weights,
+                                   long[] capacities)
+    {
+        KnapsackSolver solver = new KnapsackSolver(solverType, "test");
+        Assert.NotNull(solver);
+        solver.Init(profits, weights, capacities);
+
+        return solver.Solve();
+    }
+
+    private void SolveKnapsackProblem(long[] profits, long[,] weights, long[] capacities, long optimalProfit)
+    {
+        int maxNumberOfItemsForBruteForce = 20;
+        int maxNumberOfItemsForDivideAndConquer = 32;
+        int maxNumberOfItemsFor64ItemsSolver = 64;
+
+        {
+            long profit = RunKnapsackSolver(KnapsackSolver.SolverType.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,
+                                            profits, weights, capacities);
+            Assert.Equal(optimalProfit, profit);
+        }
+
+        // Other solvers don't support multidimension models.
+        if (weights.Length > 1)
+        {
+            return;
+        }
+
+        int numOfItems = profits.Length;
+
+        if (numOfItems <= maxNumberOfItemsForBruteForce)
+        {
+            long profit =
+                RunKnapsackSolver(KnapsackSolver.SolverType.KNAPSACK_BRUTE_FORCE_SOLVER, profits, weights, capacities);
+            Assert.Equal(optimalProfit, profit);
+        }
+
+        if (numOfItems <= maxNumberOfItemsForDivideAndConquer)
+        {
+            long profit = RunKnapsackSolver(KnapsackSolver.SolverType.KNAPSACK_DIVIDE_AND_CONQUER_SOLVER, profits,
+                                            weights, capacities);
+            Assert.Equal(optimalProfit, profit);
+        }
+
+        {
+            long profit = RunKnapsackSolver(KnapsackSolver.SolverType.KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, profits,
+                                            weights, capacities);
+            Assert.Equal(optimalProfit, profit);
+        }
+
+        if (numOfItems <= maxNumberOfItemsFor64ItemsSolver)
+        {
+            long profit =
+                RunKnapsackSolver(KnapsackSolver.SolverType.KNAPSACK_64ITEMS_SOLVER, profits, weights, capacities);
+            Assert.Equal(optimalProfit, profit);
+        }
+    }
+
+    [Fact]
+    public void SolveOneDimension()
+    {
+        long[] profits = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        long[,] weights = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
+        long[] capacities = { 34 };
+        long optimalProfit = 34;
+        SolveKnapsackProblem(profits, weights, capacities, optimalProfit);
+    }
+
+    [Fact]
+    public void SolveTwoDimensions()
+    {
+        long[] profits = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        long[,] weights = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1 } };
+        long[] capacities = { 34, 4 };
+        long optimalProfit = 30;
+        SolveKnapsackProblem(profits, weights, capacities, optimalProfit);
+    }
+
+    [Fact]
+    public void SolveBigOneDimension()
+    {
+        long[] profits = { 360, 83, 59, 130, 431, 67,  230, 52,  93,  125, 670, 892, 600, 38,  48,  147, 78,
+                           256, 63, 17, 120, 164, 432, 35,  92,  110, 22,  42,  50,  323, 514, 28,  87,  73,
+                           78,  15, 26, 78,  210, 36,  85,  189, 274, 43,  33,  10,  19,  389, 276, 312 };
+        long[,] weights = { { 7,  0,  30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0,  36, 3,  8,  15,
+                              42, 9,  0,  42, 47, 52, 32, 26, 48, 55, 6,  29, 84, 2,  4,  18, 56,
+                              7,  29, 93, 44, 71, 3,  86, 66, 31, 65, 0,  79, 20, 65, 52, 13 } };
+        long[] capacities = { 850 };
+        long optimalProfit = 7534;
+        SolveKnapsackProblem(profits, weights, capacities, optimalProfit);
+    }
+}
+} // namespace Google.OrTools.Tests