Testing (#63)

* Adding more unit tests

Author: elegoff

community-rust-frontend/src/main/java/org/sonar/rust/RustGrammar.java

@@ -563,7 +563,7 @@ private static void enumerationsItem(LexerlessGrammarBuilder b) {
       SPC, b.optional(ENUM_ITEMS), SPC, "}");
     b.rule(ENUM_ITEMS).is(seq(b, ENUM_ITEM, RustPunctuator.COMMA));
     b.rule(ENUM_ITEM).is(b.zeroOrMore(OUTER_ATTRIBUTE, SPC), b.optional(VISIBILITY, SPC),
-      IDENTIFIER, SPC, b.optional(b.firstOf(ENUM_ITEM_TUPLE, ENUM_ITEM_STRUCT, ENUM_ITEM_DISCRIMINANT)));
+      IDENTIFIER, SPC, b.optional(b.firstOf(ENUM_ITEM_TUPLE, ENUM_ITEM_STRUCT), SPC, b.optional(ENUM_ITEM_DISCRIMINANT)));
     b.rule(ENUM_ITEM_TUPLE).is("(", SPC, b.optional(TUPLE_FIELDS), SPC, ")");
     b.rule(ENUM_ITEM_STRUCT).is("{", SPC, b.optional(STRUCT_FIELDS), SPC, "}");
     b.rule(ENUM_ITEM_DISCRIMINANT).is(RustPunctuator.EQ, SPC, EXPRESSION);

community-rust-plugin/src/test/java/org/elegoff/plugins/communityrust/RustcParsingTest.java

@@ -0,0 +1,102 @@
+package org.elegoff.plugins.communityrust;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import org.elegoff.plugins.communityrust.language.RustLanguage;
+import org.fest.assertions.Assertions;
+import org.junit.Test;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.batch.fs.internal.DefaultInputFile;
+import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
+import org.sonar.api.batch.rule.CheckFactory;
+import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
+import org.sonar.api.batch.sensor.internal.SensorContextTester;
+import org.sonar.api.config.internal.MapSettings;
+import org.sonar.api.measures.FileLinesContext;
+import org.sonar.api.measures.FileLinesContextFactory;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+
+public class RustcParsingTest {
+  private final File dir = new File("src/test/resources/rustc");
+  private FileLinesContext fileLinesContext;
+  private SensorContextTester tester;
+  private RustSensor sensor;
+
+
+  public void reinit() {
+    tester = SensorContextTester.create(dir);
+
+    MapSettings settings = CommunityRustPluginConfigurationTest.getDefaultSettings();
+    tester.setSettings(settings);
+
+    FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
+    fileLinesContext = mock(FileLinesContext.class);
+    when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(fileLinesContext);
+    ActiveRulesBuilder activeRuleBuilder = new ActiveRulesBuilder();
+    CheckFactory checkFactory = new CheckFactory(activeRuleBuilder.build());
+    sensor = new RustSensor(checkFactory, fileLinesContextFactory);
+  }
+
+  private DefaultInputFile addInputFile(String fileName) throws IOException {
+    String content = new String(Files.readAllBytes(new File(dir, fileName).toPath()));
+    Assertions.assertThat(content).isNotEmpty();
+    DefaultInputFile inputFile = new TestInputFileBuilder(tester.module().key(), fileName)
+      .setModuleBaseDir(tester.fileSystem().baseDirPath())
+      .setType(InputFile.Type.MAIN)
+      .setLanguage(RustLanguage.KEY)
+      .setCharset(StandardCharsets.UTF_8)
+      .initMetadata(content)
+      .build();
+    tester.fileSystem().add(inputFile);
+    return inputFile;
+  }
+
+  private DefaultInputFile executeSensorOnSingleFile(String fileName) throws IOException {
+    DefaultInputFile inputFile = addInputFile(fileName);
+    sensor.execute(tester);
+    return inputFile;
+  }
+
+
+  private void checkme(String testfile) throws IOException {
+    reinit();
+    DefaultInputFile inputFile = executeSensorOnSingleFile(testfile);
+    verify(fileLinesContext).save();
+    Assertions.assertThat(tester.allAnalysisErrors()).isEmpty();
+  }
+
+  @Test
+  public void DebugInfoTest() throws IOException {
+    checkme("debuginfo/associated-types.rs");
+    checkme("debuginfo/borrowed-enums.rs");
+  }
+
+  @Test
+  public void RunMakeFulldepsTest() throws IOException {
+    checkme("run-make-fulldeps/atomic-lock-free/atomic_lock_free.rs");
+  }
+
+  @Test
+  public void UITest() throws IOException {
+    checkme("ui/cfg/cfg-panic.rs");
+
+    checkme("ui/borrowck/issue-88434-minimal-example.rs");
+    checkme("ui/borrowck/issue-88434-removal-index-should-be-less.rs");
+    checkme("ui/const-generics/generic_const_exprs/issue-85848.rs");
+    checkme("ui/const-generics/issues/issue-79674.rs");
+
+    checkme("ui/cfg/cfg-panic-abort.rs");
+    checkme("ui/feature-gates/feature-gate-cfg-target-has-atomic-equal-alignment.rs");
+    checkme("ui/fmt/format-args-capture.rs");
+    checkme("ui/issues/issue-68696-catch-during-unwind.rs");
+  }
+
+
+}

community-rust-plugin/src/test/resources/rustc/debuginfo/associated-types.rs

@@ -0,0 +1,155 @@
+// Some versions of the non-rust-enabled LLDB print the wrong generic
+// parameter type names in this test.
+// rust-lldb
+
+// compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+// gdb-command:run
+
+// gdb-command:print arg
+// gdbg-check:$1 = {b = -1, b1 = 0}
+// gdbr-check:$1 = associated_types::Struct<i32> {b: -1, b1: 0}
+// gdb-command:continue
+
+// gdb-command:print inferred
+// gdb-check:$2 = 1
+// gdb-command:print explicitly
+// gdb-check:$3 = 1
+// gdb-command:continue
+
+// gdb-command:print arg
+// gdb-check:$4 = 2
+// gdb-command:continue
+
+// gdb-command:print arg
+// gdbg-check:$5 = {__0 = 4, __1 = 5}
+// gdbr-check:$5 = (4, 5)
+// gdb-command:continue
+
+// gdb-command:print a
+// gdb-check:$6 = 6
+// gdb-command:print b
+// gdb-check:$7 = 7
+// gdb-command:continue
+
+// gdb-command:print a
+// gdb-check:$8 = 8
+// gdb-command:print b
+// gdb-check:$9 = 9
+// gdb-command:continue
+
+// === LLDB TESTS ==================================================================================
+// lldb-command:run
+
+// lldb-command:print arg
+// lldbg-check:[...]$0 = { b = -1, b1 = 0 }
+// lldbr-check:(associated_types::Struct<i32>) arg = { b = -1, b1 = 0 }
+// lldb-command:continue
+
+// lldb-command:print inferred
+// lldbg-check:[...]$1 = 1
+// lldbr-check:(i64) inferred = 1
+// lldb-command:print explicitly
+// lldbg-check:[...]$2 = 1
+// lldbr-check:(i64) explicitly = 1
+// lldb-command:continue
+
+// lldb-command:print arg
+// lldbg-check:[...]$3 = 2
+// lldbr-check:(i64) arg = 2
+// lldb-command:continue
+
+// lldb-command:print arg
+// lldbg-check:[...]$4 = (4, 5)
+// lldbr-check:((i32, i64)) arg = { = 4 = 5 }
+// lldb-command:continue
+
+// lldb-command:print a
+// lldbg-check:[...]$5 = 6
+// lldbr-check:(i32) a = 6
+// lldb-command:print b
+// lldbg-check:[...]$6 = 7
+// lldbr-check:(i64) b = 7
+// lldb-command:continue
+
+// lldb-command:print a
+// lldbg-check:[...]$7 = 8
+// lldbr-check:(i64) a = 8
+// lldb-command:print b
+// lldbg-check:[...]$8 = 9
+// lldbr-check:(i32) b = 9
+// lldb-command:continue
+
+#![allow(unused_variables)]
+#![allow(dead_code)]
+#![feature(omit_gdb_pretty_printer_section)]
+#![omit_gdb_pretty_printer_section]
+
+trait TraitWithAssocType {
+    type Type;
+
+    fn get_value(&self) -> Self::Type;
+}
+
+impl TraitWithAssocType for i32 {
+    type Type = i64;
+
+    fn get_value(&self) -> i64 { *self as i64 }
+}
+
+struct Struct<T: TraitWithAssocType> {
+    b: T,
+    b1: T::Type,
+}
+
+enum Enum<T: TraitWithAssocType> {
+    Variant1(T, T::Type),
+    Variant2(T::Type, T),
+}
+
+fn assoc_struct<T: TraitWithAssocType>(arg: Struct<T>) {
+    zzz(); // #break
+}
+
+fn assoc_local<T: TraitWithAssocType>(x: T) {
+    let inferred = x.get_value();
+    let explicitly: T::Type = x.get_value();
+
+    zzz(); // #break
+}
+
+fn assoc_arg<T: TraitWithAssocType>(arg: T::Type) {
+    zzz(); // #break
+}
+
+fn assoc_return_value<T: TraitWithAssocType>(arg: T) -> T::Type {
+    return arg.get_value();
+}
+
+fn assoc_tuple<T: TraitWithAssocType>(arg: (T, T::Type)) {
+    zzz(); // #break
+}
+
+fn assoc_enum<T: TraitWithAssocType>(arg: Enum<T>) {
+    match arg {
+        Enum::Variant1(a, b) => {
+            zzz(); // #break
+        }
+        Enum::Variant2(a, b) => {
+            zzz(); // #break
+        }
+    }
+}
+
+fn main() {
+    assoc_struct(Struct { b: -1, b1: 0 });
+    assoc_local(1);
+    assoc_arg::<i32>(2);
+    assoc_return_value(3);
+    assoc_tuple((4, 5));
+    assoc_enum(Enum::Variant1(6, 7));
+    assoc_enum(Enum::Variant2(8, 9));
+}
+
+fn zzz() { () }

community-rust-plugin/src/test/resources/rustc/debuginfo/borrowed-enums.rs

@@ -0,0 +1,71 @@
+// Require a gdb or lldb that can read DW_TAG_variant_part.
+// min-gdb-version: 8.2
+// rust-lldb
+
+// compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:run
+
+// gdb-command:print *the_a_ref
+// gdbr-check:$1 = borrowed_enum::ABC::TheA{x: 0, y: 8970181431921507452}
+
+// gdb-command:print *the_b_ref
+// gdbr-check:$2 = borrowed_enum::ABC::TheB(0, 286331153, 286331153)
+
+// gdb-command:print *univariant_ref
+// gdbr-check:$3 = borrowed_enum::Univariant::TheOnlyCase(4820353753753434)
+
+
+// === LLDB TESTS ==================================================================================
+
+// lldb-command:run
+
+// lldb-command:print *the_a_ref
+// lldbr-check:(borrowed_enum::ABC::TheA) *the_a_ref = TheA { TheA: 0, TheB: 8970181431921507452 }
+// lldb-command:print *the_b_ref
+// lldbr-check:(borrowed_enum::ABC::TheB) *the_b_ref = { = 0 = 286331153 = 286331153 }
+// lldb-command:print *univariant_ref
+// lldbr-check:(borrowed_enum::Univariant) *univariant_ref = { TheOnlyCase = { = 4820353753753434 } }
+
+#![allow(unused_variables)]
+#![feature(omit_gdb_pretty_printer_section)]
+#![omit_gdb_pretty_printer_section]
+
+// The first element is to ensure proper alignment, irrespective of the machines word size. Since
+// the size of the discriminant value is machine dependent, this has be taken into account when
+// datatype layout should be predictable as in this case.
+enum ABC {
+    TheA { x: i64, y: i64 },
+    TheB(i64, i32, i32),
+}
+
+// This is a special case since it does not have the implicit discriminant field.
+enum Univariant {
+    TheOnlyCase(i64)
+}
+
+fn main() {
+
+    // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452
+    // 0b01111100011111000111110001111100 = 2088533116
+    // 0b0111110001111100 = 31868
+    // 0b01111100 = 124
+    let the_a = ABC::TheA { x: 0, y: 8970181431921507452 };
+    let the_a_ref: &ABC = &the_a;
+
+    // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
+    // 0b00010001000100010001000100010001 = 286331153
+    // 0b0001000100010001 = 4369
+    // 0b00010001 = 17
+    let the_b = ABC::TheB(0, 286331153, 286331153);
+    let the_b_ref: &ABC = &the_b;
+
+    let univariant = Univariant::TheOnlyCase(4820353753753434);
+    let univariant_ref: &Univariant = &univariant;
+
+    zzz(); // #break
+}
+
+fn zzz() { () }