anchor.diff:    return splitter;
   }
   
  -NominalSplitter createNominalSplitter(List<Vector> nominalValues,
  +NominalSplitter createNominalSplitter(List<num> nominalValues,
       Map<DecisionTreeNode, Matrix> split) {
     final splitter = NominalSplitterMock();
     when(splitter.split(any, any, nominalValues)).thenReturn(split);
  
positive.code: 
          final split = splitter.split(
            samples,
            splittingColumnRange,
            null,
            splittingValues,
          );
          expect(split.values, equals(<Matrix>[]));
          verify(nominalSplitter.split(samples, splittingColumnRange, splittingValues))
              .called(1);
        });
  
        test('should throw an error if unappropriate range is given (left '
            'boundary is less than 0)', () {
          final samples = Matrix.fromList([
            [11, 22, 0, 0, 1, 30],
            [60, 23, 0, 0, 1, 20],
            [20, 25, 1, 0, 0, 10],
            [17, 66, 1, 0, 0, 70],
            [13, 99, 0, 1, 0, 30],
          ]);
          final splittingColumnRange = ZRange.closed(-2, 4);
          final splittingValues = [
            Vector.fromList([0, 0, 1]),
            Vector.fromList([0, 1, 0]),
          ];
          final splitter = GreedySplitter(null, null, null);
          final actual = () => splitter.split(
            samples,
            splittingColumnRange,
            null,
            splittingValues,
          );
          expect(actual, throwsException);
        });
  
        test('should throw an error if unappropriate range is given (right '
            'boundary is greater than the observations columns number)', () {
          final samples = Matrix.fromList([
            [11, 22, 0, 0, 1, 30],
            [60, 23, 0, 0, 1, 20],
            [20, 25, 1, 0, 0, 10],
            [17, 66, 1, 0, 0, 70],
            [13, 99, 0, 1, 0, 30],
          ]);
          final splittingColumnRange = ZRange.closed(0, 10);
          final splittingValues = [
            Vector.fromList([0, 0, 1]),
            Vector.fromList([0, 1, 0]),
          ];
          final selector = GreedySplitter(null, null, null);
          final actual = () => selector.split(
            samples,
            splittingColumnRange,
            null,
            splittingValues,
          );
  
negative.code:         final assessor = SplitAssessorMock();
  
          when(assessor.getAggregatedError(mockedWorstSplit.values,
              targetIdx)).thenReturn(0.99);
          when(assessor.getAggregatedError(mockedWorseSplit.values,
              targetIdx)).thenReturn(0.8);
          when(assessor.getAggregatedError(mockedGoodSplit.values,
              targetIdx)).thenReturn(0.4);
          when(assessor.getAggregatedError(mockedBestSplit.values,
              targetIdx)).thenReturn(0.1);
  
          final numericalSplitter = createNumericalSplitter(
              mockedSplitDataToBeReturned);
          final splitter = GreedySplitter(assessor, numericalSplitter, null);
          final actualSplit = splitter.split(inputObservations,
              splittingColumnIdx, targetIdx);
  
          for (final splitInfo in mockedSplitDataToBeReturned) {
            final splittingValue = splitInfo['splittingValue'] as double;
            verify(numericalSplitter.split(inputObservations, splittingColumnIdx,
                splittingValue)).called(1);
          }
  
  