How to use

store

method

in

org.sonar.api.batch.sensor.internal.SensorStorage

@Override
protected void doSave() {
 requireNonNull(this.inputFile, "inputFile is mandatory on AnalysisError");
 storage.store(this);
}

@Override
protected void doSave() {
 Preconditions.checkState(inputFile != null, "Call onFile() first");
 storage.store(this);
}

@Override
public void doSave() {
 requireNonNull(this.ruleKey, "ruleKey is mandatory on issue");
 checkState(primaryLocation != null, "Primary location is mandatory on every issue");
 storage.store(this);
}

@Override
public void doSave() {
 checkState(isNotBlank(engineId), "Engine id is mandatory on ad hoc rule");
 checkState(isNotBlank(ruleId), "Rule id is mandatory on ad hoc rule");
 checkState(isNotBlank(name), "Name is mandatory on every ad hoc rule");
 checkState(severity != null, "Severity is mandatory on every ad hoc rule");
 checkState(type != null, "Type is mandatory on every ad hoc rule");
 storage.store(this);
}

@Override
protected void doSave() {
 checkInputFileNotNull();
 storage.store(this);
}

@Override
public void doSave() {
 requireNonNull(this.value, "Measure value can't be null");
 requireNonNull(this.metric, "Measure metric can't be null");
 Preconditions.checkState(this.metric.valueType().equals(this.value.getClass()), "Measure value should be of type %s", this.metric.valueType());
 storage.store(this);
}

@Override
public void doSave() {
 requireNonNull(this.engineId, "Engine id is mandatory on external issue");
 requireNonNull(this.ruleId, "Rule id is mandatory on external issue");
 checkState(primaryLocation != null, "Primary location is mandatory on every external issue");
 checkState(primaryLocation.inputComponent().isFile(), "External issues must be located in files");
 checkState(primaryLocation.message() != null, "External issues must have a message");
 checkState(severity != null, "Severity is mandatory on every external issue");
 checkState(type != null, "Type is mandatory on every external issue");
 storage.store(this);
}

@Override
protected void doSave() {
 checkState(inputFile != null, "Call onFile() first");
 if (isExcludedForDuplication()) {
  return;
 }
 addNewTokensLine(result, startIndex, currentIndex, startLine, sb);
 storage.store(this);
}

@Override
public void doSave() {
 validateFile();
 if (!isExcluded()) {
  storage.store(this);
 }
}

@Test
public void shouldSave() {
 fileLineMeasures.setIntValue(HITS_METRIC_KEY, 1, 2);
 fileLineMeasures.setIntValue(HITS_METRIC_KEY, 3, 0);
 fileLineMeasures.save();
 assertThat(fileLineMeasures.toString()).isEqualTo("DefaultFileLinesContext{map={hits={1=2, 3=0}}}");
 ArgumentCaptor<DefaultMeasure> captor = ArgumentCaptor.forClass(DefaultMeasure.class);
 verify(sensorStorage).store(captor.capture());
 DefaultMeasure measure = captor.getValue();
 assertThat(measure.inputComponent()).isEqualTo(file);
 assertThat(measure.metric().key()).isEqualTo(HITS_METRIC_KEY);
 assertThat(measure.value()).isEqualTo("1=2;3=0");
}

@Test
public void save_no_tokens() {
 SensorStorage sensorStorage = mock(SensorStorage.class);
 DefaultCpdTokens tokens = new DefaultCpdTokens(sensorStorage)
  .onFile(inputFile);
 tokens.save();
 verify(sensorStorage).store(tokens);
 assertThat(tokens.inputFile()).isEqualTo(inputFile);
}

@Test
public void test_save() {
 DefaultAnalysisError analysisError = new DefaultAnalysisError(storage);
 analysisError.onFile(inputFile).save();
 verify(storage).store(analysisError);
 verifyNoMoreInteractions(storage);
}

@Test
public void build_file_measure() {
 SensorStorage storage = mock(SensorStorage.class);
 DefaultMeasure<Integer> newMeasure = new DefaultMeasure<Integer>(storage)
  .forMetric(CoreMetrics.LINES)
  .on(new TestInputFileBuilder("foo", "src/Foo.php").build())
  .withValue(3);
 assertThat(newMeasure.inputComponent()).isEqualTo(new TestInputFileBuilder("foo", "src/Foo.php").build());
 assertThat(newMeasure.metric()).isEqualTo(CoreMetrics.LINES);
 assertThat(newMeasure.value()).isEqualTo(3);
 newMeasure.save();
 verify(storage).store(newMeasure);
}

@Test
public void should_save_ranges() {
 underTest.onFile(inputFile)
  .addRange(inputFile.selectLine(1))
  .save();
 verify(sensorStorage).store(underTest);
}

@Test
public void description_is_optional() {
 SensorStorage storage = mock(SensorStorage.class);
 new DefaultAdHocRule(storage)
  .engineId("engine")
  .ruleId("ruleId")
  .name("name")
  .severity(Severity.BLOCKER)
  .type(RuleType.CODE_SMELL)
  .save();
 verify(storage).store(any(DefaultAdHocRule.class));
}

@Override
protected void doSave() {
 checkInputFileNotNull();
 // Sort rules to avoid variation during consecutive runs
 Collections.sort(syntaxHighlightingRules, (left, right) -> {
  int result = left.range().start().compareTo(right.range().start());
  if (result == 0) {
   result = right.range().end().compareTo(left.range().end());
  }
  return result;
 });
 checkOverlappingBoundaries();
 storage.store(this);
}

@Test
public void save_one_token() {
 SensorStorage sensorStorage = mock(SensorStorage.class);
 DefaultCpdTokens tokens = new DefaultCpdTokens(sensorStorage)
  .onFile(inputFile)
  .addToken(inputFile.newRange(1, 2, 1, 5), "foo");
 tokens.save();
 verify(sensorStorage).store(tokens);
 assertThat(tokens.getTokenLines()).extracting("value", "startLine", "hashCode", "startUnit", "endUnit").containsExactly(tuple("foo", 1, "foo".hashCode(), 1, 1));
}

@Test
public void optimizeValues() {
 fileLineMeasures.setIntValue(NCLOC_DATA_KEY, 1, 0);
 fileLineMeasures.setIntValue(NCLOC_DATA_KEY, 2, 1);
 fileLineMeasures.setIntValue(EXECUTABLE_LINES_DATA_KEY, 1, 0);
 fileLineMeasures.setIntValue(EXECUTABLE_LINES_DATA_KEY, 2, 1);
 fileLineMeasures.save();
 ArgumentCaptor<DefaultMeasure> captor = ArgumentCaptor.forClass(DefaultMeasure.class);
 verify(sensorStorage, times(2)).store(captor.capture());
 List<DefaultMeasure> measures = captor.getAllValues();
 assertThat(measures).extracting(DefaultMeasure::inputComponent, m -> m.metric().key(), DefaultMeasure::value)
  .containsExactlyInAnyOrder(tuple(file, NCLOC_DATA_KEY, "2=1"),
   tuple(file, EXECUTABLE_LINES_DATA_KEY, "2=1"));
}

@Test
public void build_project_measure() throws IOException {
 SensorStorage storage = mock(SensorStorage.class);
 AbstractProjectOrModule module = new DefaultInputProject(ProjectDefinition.create().setKey("foo").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
 DefaultMeasure<Integer> newMeasure = new DefaultMeasure<Integer>(storage)
  .forMetric(CoreMetrics.LINES)
  .on(module)
  .withValue(3);
 assertThat(newMeasure.inputComponent()).isEqualTo(module);
 assertThat(newMeasure.metric()).isEqualTo(CoreMetrics.LINES);
 assertThat(newMeasure.value()).isEqualTo(3);
 newMeasure.save();
 verify(storage).store(newMeasure);
}

@Test
public void save_many_tokens() {
 SensorStorage sensorStorage = mock(SensorStorage.class);
 DefaultCpdTokens tokens = new DefaultCpdTokens(sensorStorage)
  .onFile(inputFile)
  .addToken(inputFile.newRange(1, 2, 1, 5), "foo")
  .addToken(inputFile.newRange(1, 6, 1, 10), "bar")
  .addToken(inputFile.newRange(1, 20, 1, 25), "biz")
  .addToken(inputFile.newRange(2, 1, 2, 10), "next");
 tokens.save();
 verify(sensorStorage).store(tokens);
 assertThat(tokens.getTokenLines())
  .extracting("value", "startLine", "hashCode", "startUnit", "endUnit")
  .containsExactly(
   tuple("foobarbiz", 1, "foobarbiz".hashCode(), 1, 3),
   tuple("next", 2, "next".hashCode(), 4, 4));
}