anchor.diff:          final assessor = SplitAssessorMock();
   
           when(assessor.getAggregatedError(mockedWorstSplit.values,
  -            outcomesRange)).thenReturn(0.99);
  +            targetIdx)).thenReturn(0.99);
           when(assessor.getAggregatedError(mockedWorseSplit.values,
  -            outcomesRange)).thenReturn(0.8);
  +            targetIdx)).thenReturn(0.8);
           when(assessor.getAggregatedError(mockedGoodSplit.values,
  -            outcomesRange)).thenReturn(0.4);
  +            targetIdx)).thenReturn(0.4);
           when(assessor.getAggregatedError(mockedBestSplit.values,
  -            outcomesRange)).thenReturn(0.1);
  +            targetIdx)).thenReturn(0.1);
   
           final numericalSplitter = createNumericalSplitter(
               mockedSplitDataToBeReturned);
           final splitter = GreedySplitter(assessor, numericalSplitter, null);
           final actualSplit = splitter.split(inputObservations,
  -            splittingColumn, outcomesRange);
  +            splittingColumnIdx, targetIdx);
   
           for (final splitInfo in mockedSplitDataToBeReturned) {
             final splittingValue = splitInfo['splittingValue'] as double;
  -          verify(numericalSplitter.split(inputObservations, splittingColumn,
  +          verify(numericalSplitter.split(inputObservations, splittingColumnIdx,
                 splittingValue)).called(1);
           }
   
  
positive.code: 
      group('(splitting by categorical values)', () {
        test('should create split, splitting the observations into parts by '
            'given column range', () {
          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]),
            Vector.fromList([1, 0, 0]),
          ];
          final mockedSplit = {
            DecisionTreeNodeMock(): Matrix.fromList([
              [11, 22, 0, 0, 1, 30],
              [60, 23, 0, 0, 1, 20],
            ]),
            DecisionTreeNodeMock(): Matrix.fromList([
              [13, 99, 0, 1, 0, 30],
            ]),
            DecisionTreeNodeMock(): Matrix.fromList([
              [20, 25, 1, 0, 0, 10],
              [17, 66, 1, 0, 0, 70],
            ]),
          };
          final splitter = createNominalSplitter(splittingValues, mockedSplit);
          final selector = GreedySplitter(null, null, splitter);
          final actualSplit = selector.split(
            samples,
            splittingColumnRange,
            null,
            splittingValues,
          );
  
negative.code:           [0.0, 10.0],
          ]);
  
          final targetIdx = 1;
  
          final bestSplittingValue = 4.5;
          final splittingColumnIdx = 0;
  
          final mockedWorstSplit = {
            DecisionTreeNodeMock(): Matrix.fromList([[12.0, 22.0]]),
  