Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: StringValidations { public static boolean isAlphabetic(final String text) { if (text != null) { return text.matches("^[a-zA-Z]*$"); } return false; } static boolean isAlphabetic(final String text); static boolean isAlphanumeric(final String textWithDigits); static boolean isAlphanumericDash(String text); static boolean isAlphanumericSpaceUnderscore(final String textWithDigits); static boolean isEmptyString(final String text); static boolean isPunctuatedText(final String text); static boolean isPunctuatedTextWithoutSpace(final String text); static boolean isDecimal(final String number); static boolean isWholeNumber(final String number); static boolean isDigit(final String digit); static boolean isEmailAddress(final String email); static boolean isState(final String state); static boolean isZipCode(final String zipCode); static boolean isPhoneNumber(final String phoneNumber); static boolean isPassword(final String password); static boolean isStrictPassword(final String password); static boolean hasData(final String value); static boolean length(final int length, final String value); static boolean minLength(final int length, final String value); static boolean maxLength(final int length, final String value); static final String EMAIL_REGEX; }### Answer: @Test public void testIsAlphabeticReturnsTrueForValidInput() { assertTrue(StringValidations.isAlphabetic("Test")); } @Test public void testIsAlphabeticReturnsFalseForNumericChar() { assertFalse(StringValidations.isAlphabetic("T3st")); } @Test public void testIsAlphabeticReturnsFalseForSpecialCharacter() { assertFalse(StringValidations.isAlphabetic("t5@a")); }
### Question: StringValidations { public static boolean length(final int length, final String value) { return (value != null) && (value.length() == length); } static boolean isAlphabetic(final String text); static boolean isAlphanumeric(final String textWithDigits); static boolean isAlphanumericDash(String text); static boolean isAlphanumericSpaceUnderscore(final String textWithDigits); static boolean isEmptyString(final String text); static boolean isPunctuatedText(final String text); static boolean isPunctuatedTextWithoutSpace(final String text); static boolean isDecimal(final String number); static boolean isWholeNumber(final String number); static boolean isDigit(final String digit); static boolean isEmailAddress(final String email); static boolean isState(final String state); static boolean isZipCode(final String zipCode); static boolean isPhoneNumber(final String phoneNumber); static boolean isPassword(final String password); static boolean isStrictPassword(final String password); static boolean hasData(final String value); static boolean length(final int length, final String value); static boolean minLength(final int length, final String value); static boolean maxLength(final int length, final String value); static final String EMAIL_REGEX; }### Answer: @Test public void testLengthReturnsFalseIfNull() throws Exception { assertFalse(StringValidations.length(4, null)); } @Test public void testLengthReturnsTrueIfLengthMatches() throws Exception { assertTrue(StringValidations.length(4, "four")); } @Test public void testLengthReturnsFalseIfShorter() throws Exception { assertFalse(StringValidations.length(4, "two")); } @Test public void testLengthReturnsFalseIfLonger() throws Exception { assertFalse(StringValidations.length(4, "seven")); }
### Question: StringValidations { public static boolean minLength(final int length, final String value) { return (value != null) && (value.length() >= length); } static boolean isAlphabetic(final String text); static boolean isAlphanumeric(final String textWithDigits); static boolean isAlphanumericDash(String text); static boolean isAlphanumericSpaceUnderscore(final String textWithDigits); static boolean isEmptyString(final String text); static boolean isPunctuatedText(final String text); static boolean isPunctuatedTextWithoutSpace(final String text); static boolean isDecimal(final String number); static boolean isWholeNumber(final String number); static boolean isDigit(final String digit); static boolean isEmailAddress(final String email); static boolean isState(final String state); static boolean isZipCode(final String zipCode); static boolean isPhoneNumber(final String phoneNumber); static boolean isPassword(final String password); static boolean isStrictPassword(final String password); static boolean hasData(final String value); static boolean length(final int length, final String value); static boolean minLength(final int length, final String value); static boolean maxLength(final int length, final String value); static final String EMAIL_REGEX; }### Answer: @Test public void testMinLengthReturnsFalseIfNull() throws Exception { assertFalse(StringValidations.minLength(4, null)); } @Test public void testMinLengthReturnsTrueIfLengthMatches() throws Exception { assertTrue(StringValidations.minLength(4, "four")); } @Test public void testMinLengthReturnsFalseIfShorter() throws Exception { assertFalse(StringValidations.minLength(4, "two")); } @Test public void testMinLengthReturnsTrueIfLonger() throws Exception { assertTrue(StringValidations.minLength(4, "seven")); }
### Question: StringValidations { public static boolean maxLength(final int length, final String value) { return (value != null) && (value.length() <= length); } static boolean isAlphabetic(final String text); static boolean isAlphanumeric(final String textWithDigits); static boolean isAlphanumericDash(String text); static boolean isAlphanumericSpaceUnderscore(final String textWithDigits); static boolean isEmptyString(final String text); static boolean isPunctuatedText(final String text); static boolean isPunctuatedTextWithoutSpace(final String text); static boolean isDecimal(final String number); static boolean isWholeNumber(final String number); static boolean isDigit(final String digit); static boolean isEmailAddress(final String email); static boolean isState(final String state); static boolean isZipCode(final String zipCode); static boolean isPhoneNumber(final String phoneNumber); static boolean isPassword(final String password); static boolean isStrictPassword(final String password); static boolean hasData(final String value); static boolean length(final int length, final String value); static boolean minLength(final int length, final String value); static boolean maxLength(final int length, final String value); static final String EMAIL_REGEX; }### Answer: @Test public void testMaxLengthReturnsFalseIfNull() throws Exception { assertFalse(StringValidations.maxLength(4, null)); } @Test public void testMaxLengthReturnsTrueIfLengthMatches() throws Exception { assertTrue(StringValidations.maxLength(4, "four")); } @Test public void testMaxLengthReturnsTrueIfShorter() throws Exception { assertTrue(StringValidations.maxLength(4, "two")); } @Test public void testMaxLengthReturnsFalseIfLonger() throws Exception { assertFalse(StringValidations.maxLength(4, "seven")); }
### Question: Timer { public Timer start() { if (this.startTime != null) { throw new IllegalStateException("Must reset Timer before starting again"); } this.startTime = System.currentTimeMillis(); this.lapTime = this.startTime; return this; } private Timer(); static Timer getTimer(); Timer start(); Timer stop(); Timer lap(); Timer reset(); long getElapsedMilliseconds(); long getLapMilliseconds(); }### Answer: @Test public void testStart() throws InterruptedException { Timer timer = Timer.getTimer(); assertEquals(0, timer.getElapsedMilliseconds()); assertEquals(0, timer.getLapMilliseconds()); timer.start(); Thread.sleep(1); assertTrue(timer.getElapsedMilliseconds() > 0); }
### Question: Timer { public Timer lap() { if (this.startTime == null) { throw new IllegalStateException("Timer must be started before lapping."); } this.lapTime = this.getFinalTime(); return this; } private Timer(); static Timer getTimer(); Timer start(); Timer stop(); Timer lap(); Timer reset(); long getElapsedMilliseconds(); long getLapMilliseconds(); }### Answer: @Test public void testLap() throws InterruptedException { Timer timer = Timer.getTimer(); timer.start(); Thread.sleep(1); timer.lap(); Thread.sleep(1); assertTrue(timer.getLapMilliseconds() > 0); assertTrue(timer.getElapsedMilliseconds() > timer.getLapMilliseconds()); }
### Question: Timer { public Timer reset() { this.stopTime = null; this.startTime = null; this.lapTime = null; return this; } private Timer(); static Timer getTimer(); Timer start(); Timer stop(); Timer lap(); Timer reset(); long getElapsedMilliseconds(); long getLapMilliseconds(); }### Answer: @Test public void testReset() throws InterruptedException { Timer timer = Timer.getTimer(); timer.start(); timer.lap(); Thread.sleep(1); timer.reset(); assertEquals(0, timer.getElapsedMilliseconds()); assertEquals(0, timer.getLapMilliseconds()); }
### Question: Timer { public long getElapsedMilliseconds() { if (this.startTime != null) { return this.getFinalTime() - this.startTime; } return 0; } private Timer(); static Timer getTimer(); Timer start(); Timer stop(); Timer lap(); Timer reset(); long getElapsedMilliseconds(); long getLapMilliseconds(); }### Answer: @Test public void testGetElapsedMilliseconds() throws InterruptedException { Timer timer = Timer.getTimer(); assertEquals(0, timer.getElapsedMilliseconds()); timer.start(); timer.lap(); Thread.sleep(1); assertTrue(timer.getLapMilliseconds() > 0); }
### Question: Timer { public long getLapMilliseconds() { if (this.lapTime != null) { return this.getFinalTime() - this.lapTime; } return 0; } private Timer(); static Timer getTimer(); Timer start(); Timer stop(); Timer lap(); Timer reset(); long getElapsedMilliseconds(); long getLapMilliseconds(); }### Answer: @Test public void testGetLapMilliseconds() throws InterruptedException { Timer timer = Timer.getTimer(); assertEquals(0, timer.getElapsedMilliseconds()); timer.start(); timer.lap(); Thread.sleep(1); assertTrue(timer.getElapsedMilliseconds() > 0); }
### Question: PRNG extends Random { public float nextFloat(final float origin, final float bound) { return nextFloat(origin, bound, this); } protected PRNG(final long seed); protected PRNG(); int nextInt(final int origin, final int bound); long nextLong(final long origin, final long bound); long nextLong(final long n); float nextFloat(final float origin, final float bound); double nextDouble(final double origin, final double bound); static int nextInt( final int origin, final int bound, final Random random ); static long nextLong( final long origin, final long bound, final Random random ); static long nextLong(final long n, final Random random); static float nextFloat( final float origin, final float bound, final Random random ); static double nextDouble( final double origin, final double bound, final Random random ); static byte[] seedBytes(final int length); static byte[] seedBytes(final byte[] seed); static byte[] seedBytes(final long seed, final byte[] seedBytes); static byte[] seedBytes(final long seed, final int length); static long seed(); static long seed(final long base); }### Answer: @Test public void nextFloatMinMax() { final float min = 10; final float max = 100000; for (int i = 0; i < 1000; ++i) { final float value = prng.nextFloat(min, max); Assert.assertTrue(value < max); Assert.assertTrue(value >= min); } }
### Question: PRNG extends Random { public double nextDouble(final double origin, final double bound) { return nextDouble(origin, bound, this); } protected PRNG(final long seed); protected PRNG(); int nextInt(final int origin, final int bound); long nextLong(final long origin, final long bound); long nextLong(final long n); float nextFloat(final float origin, final float bound); double nextDouble(final double origin, final double bound); static int nextInt( final int origin, final int bound, final Random random ); static long nextLong( final long origin, final long bound, final Random random ); static long nextLong(final long n, final Random random); static float nextFloat( final float origin, final float bound, final Random random ); static double nextDouble( final double origin, final double bound, final Random random ); static byte[] seedBytes(final int length); static byte[] seedBytes(final byte[] seed); static byte[] seedBytes(final long seed, final byte[] seedBytes); static byte[] seedBytes(final long seed, final int length); static long seed(); static long seed(final long base); }### Answer: @Test public void nextDoubleMinMax() { final double min = 10; final double max = 100000; for (int i = 0; i < 1000; ++i) { final double value = prng.nextDouble(min, max); Assert.assertTrue(value < max); Assert.assertTrue(value >= min); } } @Test public void nextDoubleMinMaxCompatibility() { final Random random1 = new Random(123); final Random random2 = new Random(123); final int origin = 100; final int bound = 100_000_000; random1.doubles(origin, bound).limit(1000).forEach(i -> { Assert.assertEquals(i, PRNG.nextDouble(origin, bound, random2)); }); }
### Question: PRNG extends Random { public static byte[] seedBytes(final int length) { return seedBytes(new byte[length]); } protected PRNG(final long seed); protected PRNG(); int nextInt(final int origin, final int bound); long nextLong(final long origin, final long bound); long nextLong(final long n); float nextFloat(final float origin, final float bound); double nextDouble(final double origin, final double bound); static int nextInt( final int origin, final int bound, final Random random ); static long nextLong( final long origin, final long bound, final Random random ); static long nextLong(final long n, final Random random); static float nextFloat( final float origin, final float bound, final Random random ); static double nextDouble( final double origin, final double bound, final Random random ); static byte[] seedBytes(final int length); static byte[] seedBytes(final byte[] seed); static byte[] seedBytes(final long seed, final byte[] seedBytes); static byte[] seedBytes(final long seed, final int length); static long seed(); static long seed(final long base); }### Answer: @Test public void seedBytes() { final byte[] bytes = PRNG.seedBytes(-11234124332123234L, 20); }
### Question: utils { static int readInt(final byte[] bytes, final int index) { final int offset = indexInteger.BYTES; if (offset + Integer.BYTES > bytes.length) { throw new IndexOutOfBoundsException(format( "Not enough data to read int value (index=%d, bytes=%d).", index, bytes.length )); } return ((bytes[offset ] & 255) << 24) + ((bytes[offset + 1] & 255) << 16) + ((bytes[offset + 2] & 255) << 8) + ((bytes[offset + 3] & 255)); } private utils(); }### Answer: @Test public void readInt() { for (int i = 1; i < 100; ++i) { final byte[] data = new byte[i4]; final Random random = new Random(i); for (int j = 0; j < i; ++j) { System.arraycopy(utils.toBytes(random.nextInt()), 0, data, j*4, 4); } random.setSeed(i); for (int j = 0; j < i; ++j) { Assert.assertEquals(utils.readInt(data, j), random.nextInt()); } } }
### Question: utils { static long readLong(final byte[] bytes, final int index) { final int offset = indexLong.BYTES; if (offset + Long.BYTES > bytes.length) { throw new IndexOutOfBoundsException(format( "Not enough data to read long value (index=%d, bytes=%d).", index, bytes.length )); } return ((long)(bytes[offset ] & 255) << 56) + ((long)(bytes[offset + 1] & 255) << 48) + ((long)(bytes[offset + 2] & 255) << 40) + ((long)(bytes[offset + 3] & 255) << 32) + ((long)(bytes[offset + 4] & 255) << 24) + ((bytes[offset + 5] & 255) << 16) + ((bytes[offset + 6] & 255) << 8) + (bytes[offset + 7] & 255); } private utils(); }### Answer: @Test public void readLong() { for (int i = 1; i < 100; ++i) { final byte[] data = new byte[i8]; final Random random = new Random(i); for (int j = 0; j < i; ++j) { System.arraycopy(utils.toBytes(random.nextLong()), 0, data, j*8, 8); } random.setSeed(i); for (int j = 0; j < i; ++j) { Assert.assertEquals(utils.readLong(data, j), random.nextLong()); } } }
### Question: PRNG extends Random { public int nextInt(final int origin, final int bound) { return nextInt(origin, bound, this); } protected PRNG(final long seed); protected PRNG(); int nextInt(final int origin, final int bound); long nextLong(final long origin, final long bound); long nextLong(final long n); float nextFloat(final float origin, final float bound); double nextDouble(final double origin, final double bound); static int nextInt( final int origin, final int bound, final Random random ); static long nextLong( final long origin, final long bound, final Random random ); static long nextLong(final long n, final Random random); static float nextFloat( final float origin, final float bound, final Random random ); static double nextDouble( final double origin, final double bound, final Random random ); static byte[] seedBytes(final int length); static byte[] seedBytes(final byte[] seed); static byte[] seedBytes(final long seed, final byte[] seedBytes); static byte[] seedBytes(final long seed, final int length); static long seed(); static long seed(final long base); }### Answer: @Test public void nextIntMinMax() { final int min = 10; final int max = Integer.MAX_VALUE; for (int i = 0; i < 1000; ++i) { final int value = prng.nextInt(min, max - 1); Assert.assertTrue(value < max - 1); Assert.assertTrue(value >= min); } } @Test public void nextIntMinMaxCompatibility() { final Random random1 = new Random(123); final Random random2 = new Random(123); final int origin = 100; final int bound = 100000; random1.ints(origin, bound).limit(1000).forEach(i -> { Assert.assertEquals(i, PRNG.nextInt(origin, bound, random2)); }); } @Test(expectedExceptions = IllegalArgumentException.class) public void nextIntIllegalArgumentException() { prng.nextInt(1000, 10); }
### Question: Indexer { void saveRDDToEs(JavaRDD javaRDD, String docName) { JavaEsSpark.saveToEs(javaRDD, docName); } }### Answer: @Test @Ignore public void saveToEs() { Map<String, ?> numbers = ImmutableMap.of("one", 11, "two", 22); Map<String, ?> airports = ImmutableMap.of("OTP", "Otopeni1", "SFO", "San Fran1"); JavaRDD<Map<String, ?>> javaRDD = jsc.parallelize(ImmutableList.of(numbers, airports)); indexer.saveRDDToEs(javaRDD, "spark/docs"); }
### Question: SoundcloudParsingHelper { static boolean checkIfHardcodedClientIdIsValid() { try { SoundcloudStreamExtractor e = (SoundcloudStreamExtractor) SoundCloud .getStreamExtractor("https: e.fetchPage(); return e.getAudioStreams().size() >= 1; } catch (Exception ignored) { return false; } } private SoundcloudParsingHelper(); synchronized static String clientId(); static Calendar parseDateFrom(String textualUploadDate); static JsonObject resolveFor(Downloader downloader, String url); static String resolveUrlWithEmbedPlayer(String apiUrl); static String resolveIdWithEmbedPlayer(String url); static String getUsersFromApiMinItems(int minItems, ChannelInfoItemsCollector collector, String apiUrl); static String getUsersFromApi(ChannelInfoItemsCollector collector, String apiUrl); static String getStreamsFromApiMinItems(int minItems, StreamInfoItemsCollector collector, String apiUrl); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl, boolean charts); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl); @Nonnull static String getUploaderUrl(JsonObject object); @Nonnull static String getAvatarUrl(JsonObject object); static String getUploaderName(JsonObject object); }### Answer: @Test public void assertThatHardcodedClientIdIsValid() throws Exception { assertTrue("Hardcoded client id is not valid anymore", SoundcloudParsingHelper.checkIfHardcodedClientIdIsValid()); }
### Question: Utils { public static String join(final CharSequence delimiter, final Iterable<? extends CharSequence> elements) { final StringBuilder stringBuilder = new StringBuilder(); final Iterator<? extends CharSequence> iterator = elements.iterator(); while (iterator.hasNext()) { stringBuilder.append(iterator.next()); if (iterator.hasNext()) { stringBuilder.append(delimiter); } } return stringBuilder.toString(); } private Utils(); static String removeNonDigitCharacters(String toRemove); static long mixedNumberWordToLong(String numberWord); static void checkUrl(String pattern, String url); static void printErrors(List<Throwable> errors); static String replaceHttpWithHttps(final String url); static String getQueryValue(URL url, String parameterName); static URL stringToURL(String url); static boolean isHTTP(URL url); static String removeUTF8BOM(String s); static String getBaseUrl(String url); static boolean isNullOrEmpty(final String str); static boolean isNullOrEmpty(final Collection<?> collection); static boolean isNullOrEmpty(final Map map); static boolean isWhitespace(final int c); static boolean isBlank(final String string); static String join(final CharSequence delimiter, final Iterable<? extends CharSequence> elements); static final String HTTP; static final String HTTPS; }### Answer: @Test public void testJoin() { assertEquals("some,random,stuff", Utils.join(",", Arrays.asList("some", "random", "stuff"))); }
### Question: NewPipe { public static List<StreamingService> getServices() { return ServiceList.all(); } private NewPipe(); static void init(Downloader d); static void init(Downloader d, Localization l); static void init(Downloader d, Localization l, ContentCountry c); static Downloader getDownloader(); static List<StreamingService> getServices(); static StreamingService getService(int serviceId); static StreamingService getService(String serviceName); static StreamingService getServiceByUrl(String url); static int getIdOfService(String serviceName); static String getNameOfService(int id); static void setupLocalization(Localization preferredLocalization); static void setupLocalization(Localization preferredLocalization, @Nullable ContentCountry preferredContentCountry); @Nonnull static Localization getPreferredLocalization(); static void setPreferredLocalization(Localization preferredLocalization); @Nonnull static ContentCountry getPreferredContentCountry(); static void setPreferredContentCountry(ContentCountry preferredContentCountry); }### Answer: @Test public void getAllServicesTest() throws Exception { assertEquals(NewPipe.getServices().size(), ServiceList.all().size()); } @Test public void testAllServicesHaveDifferentId() throws Exception { HashSet<Integer> servicesId = new HashSet<>(); for (StreamingService streamingService : NewPipe.getServices()) { String errorMsg = "There are services with the same id = " + streamingService.getServiceId() + " (current service > " + streamingService.getServiceInfo().getName() + ")"; assertTrue(errorMsg, servicesId.add(streamingService.getServiceId())); } }
### Question: NewPipe { public static StreamingService getService(int serviceId) throws ExtractionException { for (StreamingService service : ServiceList.all()) { if (service.getServiceId() == serviceId) { return service; } } throw new ExtractionException("There's no service with the id = \"" + serviceId + "\""); } private NewPipe(); static void init(Downloader d); static void init(Downloader d, Localization l); static void init(Downloader d, Localization l, ContentCountry c); static Downloader getDownloader(); static List<StreamingService> getServices(); static StreamingService getService(int serviceId); static StreamingService getService(String serviceName); static StreamingService getServiceByUrl(String url); static int getIdOfService(String serviceName); static String getNameOfService(int id); static void setupLocalization(Localization preferredLocalization); static void setupLocalization(Localization preferredLocalization, @Nullable ContentCountry preferredContentCountry); @Nonnull static Localization getPreferredLocalization(); static void setPreferredLocalization(Localization preferredLocalization); @Nonnull static ContentCountry getPreferredContentCountry(); static void setPreferredContentCountry(ContentCountry preferredContentCountry); }### Answer: @Test public void getServiceWithId() throws Exception { assertEquals(NewPipe.getService(YouTube.getServiceId()), YouTube); } @Test public void getServiceWithName() throws Exception { assertEquals(NewPipe.getService(YouTube.getServiceInfo().getName()), YouTube); }
### Question: NewPipe { public static StreamingService getServiceByUrl(String url) throws ExtractionException { for (StreamingService service : ServiceList.all()) { if (service.getLinkTypeByUrl(url) != StreamingService.LinkType.NONE) { return service; } } throw new ExtractionException("No service can handle the url = \"" + url + "\""); } private NewPipe(); static void init(Downloader d); static void init(Downloader d, Localization l); static void init(Downloader d, Localization l, ContentCountry c); static Downloader getDownloader(); static List<StreamingService> getServices(); static StreamingService getService(int serviceId); static StreamingService getService(String serviceName); static StreamingService getServiceByUrl(String url); static int getIdOfService(String serviceName); static String getNameOfService(int id); static void setupLocalization(Localization preferredLocalization); static void setupLocalization(Localization preferredLocalization, @Nullable ContentCountry preferredContentCountry); @Nonnull static Localization getPreferredLocalization(); static void setPreferredLocalization(Localization preferredLocalization); @Nonnull static ContentCountry getPreferredContentCountry(); static void setPreferredContentCountry(ContentCountry preferredContentCountry); }### Answer: @Test public void getServiceWithUrl() throws Exception { assertEquals(getServiceByUrl("https: assertEquals(getServiceByUrl("https: assertEquals(getServiceByUrl("https: assertNotEquals(getServiceByUrl("https: }
### Question: NewPipe { public static int getIdOfService(String serviceName) { try { return getService(serviceName).getServiceId(); } catch (ExtractionException ignored) { return -1; } } private NewPipe(); static void init(Downloader d); static void init(Downloader d, Localization l); static void init(Downloader d, Localization l, ContentCountry c); static Downloader getDownloader(); static List<StreamingService> getServices(); static StreamingService getService(int serviceId); static StreamingService getService(String serviceName); static StreamingService getServiceByUrl(String url); static int getIdOfService(String serviceName); static String getNameOfService(int id); static void setupLocalization(Localization preferredLocalization); static void setupLocalization(Localization preferredLocalization, @Nullable ContentCountry preferredContentCountry); @Nonnull static Localization getPreferredLocalization(); static void setPreferredLocalization(Localization preferredLocalization); @Nonnull static ContentCountry getPreferredContentCountry(); static void setPreferredContentCountry(ContentCountry preferredContentCountry); }### Answer: @Test public void getIdWithServiceName() throws Exception { assertEquals(NewPipe.getIdOfService(YouTube.getServiceInfo().getName()), YouTube.getServiceId()); }
### Question: NewPipe { public static String getNameOfService(int id) { try { return getService(id).getServiceInfo().getName(); } catch (Exception e) { System.err.println("Service id not known"); e.printStackTrace(); return "<unknown>"; } } private NewPipe(); static void init(Downloader d); static void init(Downloader d, Localization l); static void init(Downloader d, Localization l, ContentCountry c); static Downloader getDownloader(); static List<StreamingService> getServices(); static StreamingService getService(int serviceId); static StreamingService getService(String serviceName); static StreamingService getServiceByUrl(String url); static int getIdOfService(String serviceName); static String getNameOfService(int id); static void setupLocalization(Localization preferredLocalization); static void setupLocalization(Localization preferredLocalization, @Nullable ContentCountry preferredContentCountry); @Nonnull static Localization getPreferredLocalization(); static void setPreferredLocalization(Localization preferredLocalization); @Nonnull static ContentCountry getPreferredContentCountry(); static void setPreferredContentCountry(ContentCountry preferredContentCountry); }### Answer: @Test public void getServiceNameWithId() throws Exception { assertEquals(NewPipe.getNameOfService(YouTube.getServiceId()), YouTube.getServiceInfo().getName()); }
### Question: SoundcloudParsingHelper { public static String resolveUrlWithEmbedPlayer(String apiUrl) throws IOException, ReCaptchaException, ParsingException { String response = NewPipe.getDownloader().get("https: + URLEncoder.encode(apiUrl, "UTF-8"), SoundCloud.getLocalization()).responseBody(); return Jsoup.parse(response).select("link[rel=\"canonical\"]").first().attr("abs:href"); } private SoundcloudParsingHelper(); synchronized static String clientId(); static Calendar parseDateFrom(String textualUploadDate); static JsonObject resolveFor(Downloader downloader, String url); static String resolveUrlWithEmbedPlayer(String apiUrl); static String resolveIdWithEmbedPlayer(String url); static String getUsersFromApiMinItems(int minItems, ChannelInfoItemsCollector collector, String apiUrl); static String getUsersFromApi(ChannelInfoItemsCollector collector, String apiUrl); static String getStreamsFromApiMinItems(int minItems, StreamInfoItemsCollector collector, String apiUrl); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl, boolean charts); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl); @Nonnull static String getUploaderUrl(JsonObject object); @Nonnull static String getAvatarUrl(JsonObject object); static String getUploaderName(JsonObject object); }### Answer: @Test public void resolveUrlWithEmbedPlayerTest() throws Exception { Assert.assertEquals("https: Assert.assertEquals("https: Assert.assertEquals("https: Assert.assertEquals("https: }
### Question: SoundcloudParsingHelper { public static String resolveIdWithEmbedPlayer(String url) throws IOException, ReCaptchaException, ParsingException { String response = NewPipe.getDownloader().get("https: + URLEncoder.encode(url, "UTF-8"), SoundCloud.getLocalization()).responseBody(); if (url.contains("sets") && !url.endsWith("sets") && !url.endsWith("sets/")) return Parser.matchGroup1("\"uri\":\\s\"https:\\/\\/api\\.soundcloud\\.com\\/playlists\\/((\\d)?)\"", response); return Parser.matchGroup1(",\"id\":(([^}\\n])*?),", response); } private SoundcloudParsingHelper(); synchronized static String clientId(); static Calendar parseDateFrom(String textualUploadDate); static JsonObject resolveFor(Downloader downloader, String url); static String resolveUrlWithEmbedPlayer(String apiUrl); static String resolveIdWithEmbedPlayer(String url); static String getUsersFromApiMinItems(int minItems, ChannelInfoItemsCollector collector, String apiUrl); static String getUsersFromApi(ChannelInfoItemsCollector collector, String apiUrl); static String getStreamsFromApiMinItems(int minItems, StreamInfoItemsCollector collector, String apiUrl); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl, boolean charts); static String getStreamsFromApi(StreamInfoItemsCollector collector, String apiUrl); @Nonnull static String getUploaderUrl(JsonObject object); @Nonnull static String getAvatarUrl(JsonObject object); static String getUploaderName(JsonObject object); }### Answer: @Test public void resolveIdWithEmbedPlayerTest() throws Exception { Assert.assertEquals("26057743", SoundcloudParsingHelper.resolveIdWithEmbedPlayer("https: Assert.assertEquals("16069159", SoundcloudParsingHelper.resolveIdWithEmbedPlayer("https: }
### Question: YoutubeParsingHelper { public static boolean isHardcodedClientVersionValid() throws IOException, ExtractionException { final String url = "https: Map<String, List<String>> headers = new HashMap<>(); headers.put("X-YouTube-Client-Name", Collections.singletonList("1")); headers.put("X-YouTube-Client-Version", Collections.singletonList(HARDCODED_CLIENT_VERSION)); final String response = getDownloader().get(url, headers).responseBody(); return response.length() > 50; } private YoutubeParsingHelper(); static Document parseAndCheckPage(final String url, final Response response); static boolean isYoutubeURL(URL url); static boolean isYoutubeServiceURL(URL url); static boolean isHooktubeURL(URL url); static boolean isInvidioURL(URL url); static int parseDurationString(final String input); static String getFeedUrlFrom(final String channelIdOrUser); static Calendar parseDateFrom(String textualUploadDate); static JsonObject getInitialData(String html); static boolean isHardcodedClientVersionValid(); static String getClientVersion(); static String getKey(); static boolean areHardcodedYoutubeMusicKeysValid(); static String[] getYoutubeMusicKeys(); static String getUrlFromNavigationEndpoint(JsonObject navigationEndpoint); static String getTextFromObject(JsonObject textObject, boolean html); static String getTextFromObject(JsonObject textObject); static String fixThumbnailUrl(String thumbnailUrl); static String getValidJsonResponseBody(final Response response); static JsonArray getJsonResponse(final String url, final Localization localization); static void defaultAlertsCheck(final JsonObject initialData); final static String BASE_YOUTUBE_INTENT_URL; }### Answer: @Test public void testIsHardcodedClientVersionValid() throws IOException, ExtractionException { assertTrue("Hardcoded client version is not valid anymore", YoutubeParsingHelper.isHardcodedClientVersionValid()); }
### Question: JsonUtils { @Nonnull public static Object getValue(@Nonnull JsonObject object, @Nonnull String path) throws ParsingException { List<String> keys = Arrays.asList(path.split("\\.")); object = getObject(object, keys.subList(0, keys.size() - 1)); if (null == object) throw new ParsingException("Unable to get " + path); Object result = object.get(keys.get(keys.size() - 1)); if (null == result) throw new ParsingException("Unable to get " + path); return result; } private JsonUtils(); @Nonnull static Object getValue(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static String getString(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static Boolean getBoolean(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static Number getNumber(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static JsonObject getObject(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static JsonArray getArray(@Nonnull JsonObject object, @Nonnull String path); @Nonnull static List<Object> getValues(@Nonnull JsonArray array, @Nonnull String path); static final JsonObject EMPTY_OBJECT; static final JsonArray EMPTY_ARRAY; static final String EMPTY_STRING; }### Answer: @Test public void testGetValueFlat() throws JsonParserException, ParsingException { JsonObject obj = JsonParser.object().from("{\"name\":\"John\",\"age\":30,\"cars\":{\"car1\":\"Ford\",\"car2\":\"BMW\",\"car3\":\"Fiat\"}}"); assertTrue("John".equals(JsonUtils.getValue(obj, "name"))); } @Test public void testGetValueNested() throws JsonParserException, ParsingException { JsonObject obj = JsonParser.object().from("{\"name\":\"John\",\"age\":30,\"cars\":{\"car1\":\"Ford\",\"car2\":\"BMW\",\"car3\":\"Fiat\"}}"); assertTrue("BMW".equals(JsonUtils.getValue(obj, "cars.car2"))); }
### Question: ServiceTree { public boolean hasNodeWithKey(@NonNull Object key) { checkKey(key); return nodeMap.containsKey(key); } boolean hasNodeWithKey(@NonNull Object key); @NonNull Node createRootNode(@NonNull Object nodeKey); @NonNull Node createChildNode(@NonNull Node parentNode, @NonNull Object nodeKey); @NonNull Node getNode(@NonNull Object key); void traverseTree(@Walk.Mode final int mode, @NonNull final Walk walk); void traverseTree(@Walk.Mode final int mode, boolean includeTreeRoot, @NonNull final Walk walk); void removeAllNodes(); void removeNodeAndChildren(@NonNull Node node); void traverseSubtree(@NonNull final Node node, @Walk.Mode final int mode, @NonNull final Walk walk); void traverseChain(@NonNull Node node, @NonNull Walk walk); void traverseChain(@NonNull Node node, boolean includeTreeRoot, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, final boolean includeTreeRoot, @NonNull Walk walk); @NonNull Node findRoot(@NonNull Node child); @NonNull Set<Object> getKeys(); Node getTreeRoot(); void registerRootService(@NonNull String name, @NonNull Object service); boolean hasRootService(String name); @NonNull T getRootService(String name); T unregisterRootService(String name); }### Answer: @Test public void rootIsNotInNodeMap() { ServiceTree serviceTree = new ServiceTree(); assertThat(serviceTree.hasNodeWithKey(serviceTree.root.getKey())).isFalse(); } @Test public void keyCannotBeNull() { ServiceTree serviceTree = new ServiceTree(); try { serviceTree.hasNodeWithKey(null); } catch(NullPointerException e) { } }
### Question: ServiceTree { public void traverseTree(@Walk.Mode final int mode, @NonNull final Walk walk) { traverseTree(mode, false, walk); } boolean hasNodeWithKey(@NonNull Object key); @NonNull Node createRootNode(@NonNull Object nodeKey); @NonNull Node createChildNode(@NonNull Node parentNode, @NonNull Object nodeKey); @NonNull Node getNode(@NonNull Object key); void traverseTree(@Walk.Mode final int mode, @NonNull final Walk walk); void traverseTree(@Walk.Mode final int mode, boolean includeTreeRoot, @NonNull final Walk walk); void removeAllNodes(); void removeNodeAndChildren(@NonNull Node node); void traverseSubtree(@NonNull final Node node, @Walk.Mode final int mode, @NonNull final Walk walk); void traverseChain(@NonNull Node node, @NonNull Walk walk); void traverseChain(@NonNull Node node, boolean includeTreeRoot, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, final boolean includeTreeRoot, @NonNull Walk walk); @NonNull Node findRoot(@NonNull Node child); @NonNull Set<Object> getKeys(); Node getTreeRoot(); void registerRootService(@NonNull String name, @NonNull Object service); boolean hasRootService(String name); @NonNull T getRootService(String name); T unregisterRootService(String name); }### Answer: @Test public void walkCannotBeNull() { ServiceTree serviceTree = new ServiceTree(); try { serviceTree.traverseTree(ServiceTree.Walk.POST_ORDER, null); } catch(NullPointerException e) { } }
### Question: ServiceTree { public void registerRootService(@NonNull String name, @NonNull Object service) { checkName(name); checkService(name); root.bindService(name, service); } boolean hasNodeWithKey(@NonNull Object key); @NonNull Node createRootNode(@NonNull Object nodeKey); @NonNull Node createChildNode(@NonNull Node parentNode, @NonNull Object nodeKey); @NonNull Node getNode(@NonNull Object key); void traverseTree(@Walk.Mode final int mode, @NonNull final Walk walk); void traverseTree(@Walk.Mode final int mode, boolean includeTreeRoot, @NonNull final Walk walk); void removeAllNodes(); void removeNodeAndChildren(@NonNull Node node); void traverseSubtree(@NonNull final Node node, @Walk.Mode final int mode, @NonNull final Walk walk); void traverseChain(@NonNull Node node, @NonNull Walk walk); void traverseChain(@NonNull Node node, boolean includeTreeRoot, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, final boolean includeTreeRoot, @NonNull Walk walk); @NonNull Node findRoot(@NonNull Node child); @NonNull Set<Object> getKeys(); Node getTreeRoot(); void registerRootService(@NonNull String name, @NonNull Object service); boolean hasRootService(String name); @NonNull T getRootService(String name); T unregisterRootService(String name); }### Answer: @Test public void rootServiceCannotBeNull() { ServiceTree serviceTree = new ServiceTree(); try { serviceTree.registerRootService("SERVICE", null); } catch(NullPointerException e) { } } @Test public void rootServiceNameCannotBeNull() { ServiceTree serviceTree = new ServiceTree(); try { serviceTree.registerRootService(null, new Object()); } catch(NullPointerException e) { } }
### Question: ServiceTree { @NonNull public Node createChildNode(@NonNull Node parentNode, @NonNull Object nodeKey) { checkNode(parentNode); checkKey(nodeKey); Node node = new Node(this, parentNode, nodeKey); parentNode.children.add(node); this.addNode(node); return node; } boolean hasNodeWithKey(@NonNull Object key); @NonNull Node createRootNode(@NonNull Object nodeKey); @NonNull Node createChildNode(@NonNull Node parentNode, @NonNull Object nodeKey); @NonNull Node getNode(@NonNull Object key); void traverseTree(@Walk.Mode final int mode, @NonNull final Walk walk); void traverseTree(@Walk.Mode final int mode, boolean includeTreeRoot, @NonNull final Walk walk); void removeAllNodes(); void removeNodeAndChildren(@NonNull Node node); void traverseSubtree(@NonNull final Node node, @Walk.Mode final int mode, @NonNull final Walk walk); void traverseChain(@NonNull Node node, @NonNull Walk walk); void traverseChain(@NonNull Node node, boolean includeTreeRoot, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, @NonNull Walk walk); void traverseChain(@NonNull Node node, @Walk.Mode final int mode, final boolean includeTreeRoot, @NonNull Walk walk); @NonNull Node findRoot(@NonNull Node child); @NonNull Set<Object> getKeys(); Node getTreeRoot(); void registerRootService(@NonNull String name, @NonNull Object service); boolean hasRootService(String name); @NonNull T getRootService(String name); T unregisterRootService(String name); }### Answer: @Test public void nodeCannotBeNull() { ServiceTree serviceTree = new ServiceTree(); try { serviceTree.createChildNode(null, "key"); } catch(NullPointerException e) { } }
### Question: LessProfile extends ProfileDefinition { @Override public RulesProfile createProfile(ValidationMessages messages) { AnnotationBasedProfileBuilder annotationBasedProfileBuilder = new AnnotationBasedProfileBuilder(ruleFinder); return annotationBasedProfileBuilder.build( CheckList.LESS_REPOSITORY_KEY, SONARQUBE_WAY_PROFILE_NAME, LessLanguage.KEY, CheckList.getLessChecks(), messages); } LessProfile(RuleFinder ruleFinder); @Override RulesProfile createProfile(ValidationMessages messages); static final String SONARQUBE_WAY_PROFILE_NAME; }### Answer: @Test public void should_create_sonarqube_way_profile() { ValidationMessages validation = ValidationMessages.create(); LessProfile definition = new LessProfile(universalRuleFinder()); RulesProfile profile = definition.createProfile(validation); assertThat(profile.getName()).isEqualTo("SonarQube Way"); assertThat(profile.getLanguage()).isEqualTo("less"); assertThat(profile.getActiveRulesByRepository("less")).hasSize(73); assertThat(validation.hasErrors()).isFalse(); }
### Question: ScssVariableNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitScssVariableDeclaration(ScssVariableDeclarationTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("variable-naming-convention/scssVariableNamingConventionCustomFormat.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnScssFile(check, CheckTestUtils.getScssTestFile("variable-naming-convention/scssVariableNamingConvention.scss")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check scss:scss-variable-naming-convention (SCSS variables should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } } @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("variable-naming-convention/scssVariableNamingConvention.scss")); }
### Question: TypeSelectorCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setAllowedTypes(String allowedTypes) { this.allowedTypes = allowedTypes; } @Override void visitTypeSelector(TypeSelectorTree tree); }### Answer: @Test public void test_css_with_excludes() { TypeSelectorCheck check = new TypeSelectorCheck(); check.setAllowedTypes("a, span"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("type-selector/typeSelectorExcluded.css")); } @Test public void test_css_with_excludes_case_insensitive() { TypeSelectorCheck check = new TypeSelectorCheck(); check.setAllowedTypes("A, SpAn"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("type-selector/typeSelectorExcluded.css")); }
### Question: IdSelectorNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitIdSelector(IdSelectorTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]$"); CssCheckVerifier.verifyCssFile(check, getTestFile("selectorNamingConvention.css")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyCssFile(check, getTestFile("selectorNamingConventionCustomFormat.css")); } @Test public void test_interpolated_selectors_not_checked_on_less_file() { check.setFormat("^[a-z][-a-z0-9]$"); CssCheckVerifier.verifyLessFile(check, getTestFile("selectorNamingConvention.less")); } @Test public void test_interpolated_selectors_not_checked_on_scss_file() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, getTestFile("selectorNamingConvention.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnCssFile(check, CheckTestUtils.getCommonTestFile("selectorNamingConvention/selectorNamingConvention.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:id-selector-naming-convention (ID selectors should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: ExperimentalAtRuleCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setAtRulesToExclude(String atRulesToExclude) { this.atRulesToExclude = atRulesToExclude; } @Override void visitAtRule(AtRuleTree tree); @Override void validateParameters(); }### Answer: @Test public void test_css_exclude_at_rules() { ExperimentalAtRuleCheck check = new ExperimentalAtRuleCheck(); check.setAtRulesToExclude("custom-media\|count."); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalAtRuleUsageExcludeAtRules.css")); } @Test public void test_less_exclude_at_rules() { ExperimentalAtRuleCheck check = new ExperimentalAtRuleCheck(); check.setAtRulesToExclude("custom-media\|count."); CssCheckVerifier.verifyLessFile(check, getTestFile("experimentalAtRuleUsageExcludeAtRules.less")); } @Test public void test_scss_exclude_at_rules() { ExperimentalAtRuleCheck check = new ExperimentalAtRuleCheck(); check.setAtRulesToExclude("custom-media\|count.*"); CssCheckVerifier.verifyScssFile(check, getTestFile("experimentalAtRuleUsageExcludeAtRules.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_atRulesToExclude_parameter_is_not_valid() { try { ExperimentalAtRuleCheck check = new ExperimentalAtRuleCheck(); check.setAtRulesToExclude("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("experimentalAtRuleUsage.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:experimental-atrule-usage (Experimental @-rules should not be used): " + "atRulesToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: Plugin implements org.sonar.api.Plugin { @Override public void define(Context context) { context.addExtensions( CssLanguage.class, ScssLanguage.class, LessLanguage.class, CssAnalyzerSensor.class, EmbeddedCssAnalyzerSensor.class, ScssAnalyzerSensor.class, LessAnalyzerSensor.class, CssProfile.class, ScssProfile.class, LessProfile.class, CssRulesDefinition.class, ScssRulesDefinition.class, LessRulesDefinition.class); } @Override void define(Context context); static final String CSS_FILE_SUFFIXES_KEY; static final String CSS_FILE_SUFFIXES_DEFAULT_VALUE; static final String EMBEDDED_CSS_FILE_SUFFIXES_KEY; static final String EMBEDDED_CSS_FILE_SUFFIXES_DEFAULT_VALUE; static final String SCSS_FILE_SUFFIXES_KEY; static final String SCSS_FILE_SUFFIXES_DEFAULT_VALUE; static final String LESS_FILE_SUFFIXES_KEY; static final String LESS_FILE_SUFFIXES_DEFAULT_VALUE; }### Answer: @Test public void should_get_the_right_version() { Context context = new Context(Version.create(5, 6)); new Plugin().define(context); assertThat(context.getSonarQubeVersion().major()).isEqualTo(5); assertThat(context.getSonarQubeVersion().minor()).isEqualTo(6); } @Test public void should_get_the_right_number_of_extensions() { Context context = new Context(Version.create(5, 6)); new Plugin().define(context); assertThat(context.getExtensions()).hasSize(13); }
### Question: ExperimentalPropertyCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setPropertiesToExclude(String propertiesToExclude) { this.propertiesToExclude = propertiesToExclude; } @Override void visitProperty(PropertyTree tree); @Override void validateParameters(); }### Answer: @Test public void test_css_exclude_properties() { ExperimentalPropertyCheck check = new ExperimentalPropertyCheck(); check.setPropertiesToExclude("user-select\|voice."); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalPropertyUsageExcludeProperties.css")); } @Test public void test_less_exclude_properties() { ExperimentalPropertyCheck check = new ExperimentalPropertyCheck(); check.setPropertiesToExclude("user-select\|voice."); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalPropertyUsageExcludeProperties.less")); } @Test public void test_scss_exclude_properties() { ExperimentalPropertyCheck check = new ExperimentalPropertyCheck(); check.setPropertiesToExclude("user-select\|voice.*"); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalPropertyUsageExcludeProperties.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_propertiesToExclude_parameter_is_not_valid() { try { ExperimentalPropertyCheck check = new ExperimentalPropertyCheck(); check.setPropertiesToExclude("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("experimentalPropertyUsage.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:experimental-property-usage (Experimental properties should not be used): " + "propertiesToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: ExperimentalPseudoCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setPseudosToExclude(String pseudosToExclude) { this.pseudosToExclude = pseudosToExclude; } @Override void visitPseudoFunction(PseudoFunctionTree tree); @Override void visitPseudoIdentifier(PseudoIdentifierTree tree); @Override void validateParameters(); }### Answer: @Test public void test_css_exclude_pseudos() { ExperimentalPseudoCheck check = new ExperimentalPseudoCheck(); check.setPseudosToExclude("any-link\|cont."); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalPseudoUsageExcludePseudos.css")); } @Test public void test_less_exclude_pseudos() { ExperimentalPseudoCheck check = new ExperimentalPseudoCheck(); check.setPseudosToExclude("any-link\|cont."); CssCheckVerifier.verifyLessFile(check, getTestFile("experimentalPseudoUsageExcludePseudos.less")); } @Test public void test_scss_exclude_pseudos() { ExperimentalPseudoCheck check = new ExperimentalPseudoCheck(); check.setPseudosToExclude("any-link\|cont.*"); CssCheckVerifier.verifyScssFile(check, getTestFile("experimentalPseudoUsageExcludePseudos.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_pseudosToExclude_parameter_is_not_valid() { try { ExperimentalPseudoCheck check = new ExperimentalPseudoCheck(); check.setPseudosToExclude("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("experimentalPseudoUsage.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:experimental-pseudo-usage (Experimental pseudo-elements and pseudo-classes should not be used): " + "pseudosToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: NumberOfRulesPerSheetCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setMax(int max) { this.max = max; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void visitAtRule(AtRuleTree tree); @Override void visitRuleset(RulesetTree tree); }### Answer: @Test public void should_contain_more_rules_than_the_allowed_number_and_raise_an_issue() { NumberOfRulesPerSheetCheck check = new NumberOfRulesPerSheetCheck(); check.setMax(9); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("maximumNumberOfRulesPerSheet9.css")); } @Test public void should_contain_fewer_rules_than_the_allowed_number_and_not_raise_an_issue() { NumberOfRulesPerSheetCheck check = new NumberOfRulesPerSheetCheck(); check.setMax(11); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("maximumNumberOfRulesPerSheet11.css")); } @Test public void should_contain_the_same_number_of_rules_than_the_allowed_number_and_not_raise_an_issue() { NumberOfRulesPerSheetCheck check = new NumberOfRulesPerSheetCheck(); check.setMax(10); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("maximumNumberOfRulesPerSheet10.css")); }
### Question: TooManyWebFontsCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFontFaceThreshold(int fontFaceThreshold) { this.fontFaceThreshold = fontFaceThreshold; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void visitAtKeyword(AtKeywordTree tree); }### Answer: @Test public void test() { TooManyWebFontsCheck check = new TooManyWebFontsCheck(); check.setFontFaceThreshold(3); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("toomanywebfonts.css")); }
### Question: OverspecificSelectorCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setDeepnessThreshold(int deepnessThreshold) { this.deepnessThreshold = deepnessThreshold; } @Override void visitSelector(SelectorTree tree); }### Answer: @Test public void test_with_custom_threshold() { check.setDeepnessThreshold(5); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("overspecselectorCustom.css")); }
### Question: LineLengthCheck extends DoubleDispatchVisitorCheck implements CharsetAwareVisitor { @VisibleForTesting void setMaximumLineLength(int maximumLineLength) { this.maximumLineLength = maximumLineLength; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void setCharset(Charset charset); }### Answer: @Test public void should_find_one_line_longer_than_50_characters_and_raise_an_issue() { check.setMaximumLineLength(50); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("lineLength50.css")); } @Test public void should_find_two_lines_longer_than_30_characters_and_raise_issues() { check.setMaximumLineLength(30); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("lineLength30.css")); }
### Question: FileTooManyLinesCheck extends DoubleDispatchVisitorCheck implements CharsetAwareVisitor { @VisibleForTesting void setMax(int max) { this.max = max; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void setCharset(Charset charset); }### Answer: @Test public void should_contain_more_lines_than_the_allowed_number_and_raise_an_issue() { check.setMax(9); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("file-too-many-lines/fileTooManyLines9.css")); } @Test public void should_contain_fewer_lines_than_the_allowed_number_and_not_raise_an_issue() { check.setMax(11); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("file-too-many-lines/fileTooManyLines10.css")); } @Test public void should_contain_the_same_number_of_lines_than_the_allowed_number_and_not_raise_an_issue() { check.setMax(10); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("file-too-many-lines/fileTooManyLines11.css")); }
### Question: CssLanguage extends AbstractLanguage { @Override public String[] getFileSuffixes() { String[] suffixes = settings.getStringArray(Plugin.CSS_FILE_SUFFIXES_KEY); if (suffixes == null \|\| suffixes.length == 0) { suffixes = StringUtils.split(Plugin.CSS_FILE_SUFFIXES_DEFAULT_VALUE, ","); } return suffixes; } CssLanguage(Settings settings); @Override String[] getFileSuffixes(); static final String KEY; static final String NAME; }### Answer: @Test public void default_file_suffix() { CssLanguage language = new CssLanguage(mock(Settings.class)); assertThat(language.getFileSuffixes()).containsOnly("css"); } @Test public void custom_file_suffixes() { Settings settings = new Settings(); settings.setProperty("sonar.css.file.suffixes", "css,css3"); CssLanguage language = new CssLanguage(settings); assertThat(language.getFileSuffixes()).containsOnly("css", "css3"); }
### Question: FontFaceBrowserCompatibilityCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setBrowserSupportLevel(String browserSupportLevel) { this.browserSupportLevel = browserSupportLevel; } @Override void visitAtRule(AtRuleTree tree); @Override void validateParameters(); }### Answer: @Test public void deep() { FontFaceBrowserCompatibilityCheck check = new FontFaceBrowserCompatibilityCheck(); check.setBrowserSupportLevel("deep"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("fontface/deep.css")); } @Test public void deepest() { FontFaceBrowserCompatibilityCheck check = new FontFaceBrowserCompatibilityCheck(); check.setBrowserSupportLevel("deepest"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCommonTestFile("fontface/deepest.css")); } @Test public void should_throw_an_illegal_state_exception_as_the_browserLevelSupport_parameter_is_not_valid() { try { FontFaceBrowserCompatibilityCheck check = new FontFaceBrowserCompatibilityCheck(); check.setBrowserSupportLevel("blabla"); CssCheckVerifier.issuesOnCssFile(check, CheckTestUtils.getCommonTestFile("fontface/deepest.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:font-face-browser-compatibility (\"@font-face\" rule should " + "be made compatible with the required browsers): parameter value is not valid.\n" + "Actual: 'blabla'\n" + "Expected: 'basic' or 'deep' or 'deepest'"); } }
### Question: FontFamilyNotEndingWithGenericFontFamilyCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setExclusions(String exclusions) { this.exclusions = exclusions; } @Override void visitPropertyDeclaration(PropertyDeclarationTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_custom_format() { FontFamilyNotEndingWithGenericFontFamilyCheck check = new FontFamilyNotEndingWithGenericFontFamilyCheck(); check.setExclusions("^My-.+$"); CssCheckVerifier.verifyCssFile(check, getTestFile("fontFamilyNotEndingWithGenericFontFamilyCustomExclusions.css")); } @Test public void should_throw_an_illegal_state_exception_as_the_exclusions_parameter_is_not_valid() { try { FontFamilyNotEndingWithGenericFontFamilyCheck check = new FontFamilyNotEndingWithGenericFontFamilyCheck(); check.setExclusions("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("fontFamilyNotEndingWithGenericFontFamily.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:font-family-not-ending-with-generic-font-family (font-family properties should end with a generic font family): " + "exclusions parameter \"(\" is not a valid regular expression."); } }
### Question: NumberPrecisionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setPrecision(int precision) { this.precision = precision; } @Override void visitNumber(NumberTree tree); }### Answer: @Test public void test_css_custom_threshold() { NumberPrecisionCheck check = new NumberPrecisionCheck(); check.setPrecision(2); CssCheckVerifier.verifyCssFile(check, getTestFile("numberPrecisionCustomThreshold.css")); }
### Question: ClassSelectorNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitClassSelector(ClassSelectorTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]$"); CssCheckVerifier.verifyCssFile(check, getTestFile("selectorNamingConvention.css")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyCssFile(check, getTestFile("selectorNamingConventionCustomFormat.css")); } @Test public void test_interpolated_selectors_not_checked_on_less_file() { check.setFormat("^[a-z][-a-z0-9]$"); CssCheckVerifier.verifyLessFile(check, getTestFile("selectorNamingConvention.less")); } @Test public void test_interpolated_selectors_not_checked_on_scss_file() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, getTestFile("selectorNamingConvention.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnCssFile(check, CheckTestUtils.getCommonTestFile("selectorNamingConvention/selectorNamingConvention.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:class-selector-naming-convention (Class selectors should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: UnknownTypeSelectorCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setExclusions(String exclusions) { this.exclusions = exclusions; } @Override void visitTypeSelector(TypeSelectorTree tree); @Override void validateParameters(); static final List<String> KNOWN_HTML_TAGS; static final List<String> KNOWN_SVG_TAGS; }### Answer: @Test public void test_css_custom_type_selector() { UnknownTypeSelectorCheck check = new UnknownTypeSelectorCheck(); check.setExclusions("custom-."); CssCheckVerifier.verifyCssFile(check, getTestFile("unknownTypeSelectorCustom.css")); } @Test public void test_less_custom_type_selector() { UnknownTypeSelectorCheck check = new UnknownTypeSelectorCheck(); check.setExclusions("custom-."); CssCheckVerifier.verifyLessFile(check, getTestFile("unknownTypeSelectorCustom.less")); } @Test public void test_scss_custom_type_selector() { UnknownTypeSelectorCheck check = new UnknownTypeSelectorCheck(); check.setExclusions("custom-.*"); CssCheckVerifier.verifyScssFile(check, getTestFile("unknownTypeSelectorCustom.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_exclusions_parameter_is_not_valid() { try { UnknownTypeSelectorCheck check = new UnknownTypeSelectorCheck(); check.setExclusions("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("unknownTypeSelector.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:unknown-type-selector (Unknown type selectors " + "should be removed): exclusions parameter \"(\" is not a valid regular expression."); } }
### Question: ExperimentalIdentifierCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setIdentifiersToExclude(String identifiersToExclude) { this.identifiersToExclude = identifiersToExclude; } @Override void visitValue(ValueTree tree); @Override void validateParameters(); }### Answer: @Test public void test_exclude_identifiers() { ExperimentalIdentifierCheck check = new ExperimentalIdentifierCheck(); check.setIdentifiersToExclude("flex\|defin.*"); CssCheckVerifier.verifyCssFile(check, getTestFile("experimentalIdentifierUsageExcludeIdentifiers.css")); } @Test public void should_throw_an_illegal_state_exception_as_the_identifiersToExclude_parameter_is_not_valid() { try { ExperimentalIdentifierCheck check = new ExperimentalIdentifierCheck(); check.setIdentifiersToExclude("("); CssCheckVerifier.issuesOnCssFile(check, getTestFile("experimentalIdentifierUsage.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:experimental-identifier-usage (Experimental identifiers should not be used): " + "identifiersToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: ExperimentalCssFunctionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFunctionsToExclude(String functionsToExclude) { this.functionsToExclude = functionsToExclude; } @Override void visitFunction(FunctionTree tree); @Override void validateParameters(); }### Answer: @Test public void test_exclude_functions() { ExperimentalCssFunctionCheck check = new ExperimentalCssFunctionCheck(); check.setFunctionsToExclude("conic-gradient\|count.*"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCssTestFile("experimentalFunctionUsageExcludeFunctions.css")); } @Test public void should_throw_an_illegal_state_exception_as_the_functionsToExclude_parameter_is_not_valid() { try { ExperimentalCssFunctionCheck check = new ExperimentalCssFunctionCheck(); check.setFunctionsToExclude("("); CssCheckVerifier.issuesOnCssFile(check, CheckTestUtils.getCssTestFile("experimentalFunctionUsage.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:experimental-function-usage (Experimental functions should not be used): " + "functionsToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: CssRulesDefinition implements RulesDefinition { @Override public void define(Context context) { NewRepository repository = context .createRepository(CheckList.CSS_REPOSITORY_KEY, CssLanguage.KEY) .setName(CheckList.CSS_REPOSITORY_NAME); new AnnotationBasedRulesDefinition(repository, CssLanguage.KEY).addRuleClasses(false, CheckList.getCssChecks()); repository.done(); } @Override void define(Context context); }### Answer: @Test public void test() { CssRulesDefinition rulesDefinition = new CssRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository("css"); assertThat(repository.name()).isEqualTo("SonarQube"); assertThat(repository.language()).isEqualTo("css"); assertThat(repository.rules()).hasSize(88); assertThat(CheckList.getEmbeddedCssChecks()).hasSize(repository.rules().size() - 6); RulesDefinition.Rule todoRule = repository.rule(TodoTagCheck.class.getAnnotation(Rule.class).key()); assertThat(todoRule).isNotNull(); assertThat(todoRule.name()).isEqualTo(TodoTagCheck.class.getAnnotation(Rule.class).name()); }
### Question: CssVariableNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitVariableDeclaration(VariableDeclarationTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCssTestFile("variable-naming-convention/variableNamingConvention.css")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyCssFile(check, CheckTestUtils.getCssTestFile("variable-naming-convention/variableNamingConventionCustomFormat.css")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnCssFile(check, CheckTestUtils.getCssTestFile("variable-naming-convention/variableNamingConvention.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check css:css-variable-naming-convention (CSS variables should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: CssAnalyzerSensor extends AbstractLanguageAnalyzerSensor { @Override public void describe(SensorDescriptor descriptor) { descriptor .onlyOnLanguage(CssLanguage.KEY) .name("CSS Analyzer Sensor") .onlyOnFileType(Type.MAIN); } CssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter); CssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter, @Nullable CustomCssRulesDefinition[] customRulesDefinition); @Override void describe(SensorDescriptor descriptor); @Override String analyzerName(); @Override String language(); @Override ActionParser<Tree> parser(FileSystem fileSystem); @Override List<InputFile> filesToAnalyze(FileSystem fileSystem); @Override Checks checks(CheckFactory checkFactory, CustomRulesDefinition[] customRulesDefinitions); @Override List<TreeVisitor> treeVisitors(SensorContext sensorContext, Checks checks, NoSonarFilter noSonarFilter); @Override Class parsingErrorCheck(); }### Answer: @Test public void should_create_a_valid_sensor_descriptor() { DefaultSensorDescriptor descriptor = new DefaultSensorDescriptor(); createCssSquidSensor().describe(descriptor); assertThat(descriptor.name()).isEqualTo("CSS Analyzer Sensor"); assertThat(descriptor.languages()).containsOnly("css"); assertThat(descriptor.type()).isEqualTo(InputFile.Type.MAIN); }
### Question: CssProfile extends ProfileDefinition { @Override public RulesProfile createProfile(ValidationMessages messages) { AnnotationBasedProfileBuilder annotationBasedProfileBuilder = new AnnotationBasedProfileBuilder(ruleFinder); return annotationBasedProfileBuilder.build( CheckList.CSS_REPOSITORY_KEY, SONARQUBE_WAY_PROFILE_NAME, CssLanguage.KEY, CheckList.getCssChecks(), messages); } CssProfile(RuleFinder ruleFinder); @Override RulesProfile createProfile(ValidationMessages messages); static final String SONARQUBE_WAY_PROFILE_NAME; }### Answer: @Test public void should_create_sonarqube_way_profile() { ValidationMessages validation = ValidationMessages.create(); CssProfile definition = new CssProfile(universalRuleFinder()); RulesProfile profile = definition.createProfile(validation); assertThat(profile.getName()).isEqualTo("SonarQube Way"); assertThat(profile.getLanguage()).isEqualTo("css"); assertThat(profile.getActiveRulesByRepository("css")).hasSize(73); assertThat(validation.hasErrors()).isFalse(); }
### Question: EmbeddedCssAnalyzerSensor extends AbstractLanguageAnalyzerSensor { @Override public void describe(SensorDescriptor descriptor) { descriptor.name("Embedded CSS Analyzer Sensor"); } EmbeddedCssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter); EmbeddedCssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter, @Nullable CustomCssRulesDefinition[] customRulesDefinition); @Override void describe(SensorDescriptor descriptor); @Override String analyzerName(); @Override String language(); @Override ActionParser<Tree> parser(FileSystem fileSystem); @Override List<InputFile> filesToAnalyze(FileSystem fileSystem); @Override Checks checks(CheckFactory checkFactory, CustomRulesDefinition[] customRulesDefinitions); @Override List<TreeVisitor> treeVisitors(SensorContext sensorContext, Checks checks, NoSonarFilter noSonarFilter); @Override Class parsingErrorCheck(); }### Answer: @Test public void should_create_a_valid_sensor_descriptor() { DefaultSensorDescriptor descriptor = new DefaultSensorDescriptor(); createEmbeddedCssSquidSensor().describe(descriptor); assertThat(descriptor.name()).isEqualTo("Embedded CSS Analyzer Sensor"); assertThat(descriptor.languages()).isEmpty(); assertThat(descriptor.type()).isNull(); }
### Question: CustomScssRulesDefinition implements CustomRulesDefinition { @Override public void define(Context context) { NewRepository repo = context.createRepository(repositoryKey(), "scss").setName(repositoryName()); new AnnotationBasedRulesDefinition(repo, "scss").addRuleClasses(false, ImmutableList.copyOf(checkClasses())); repo.done(); } @Override void define(Context context); }### Answer: @Test public void test() { MyCustomScssRulesDefinition rulesDefinition = new MyCustomScssRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository(REPOSITORY_KEY); assertThat(repository.name()).isEqualTo(REPOSITORY_NAME); assertThat(repository.language()).isEqualTo("scss"); assertThat(repository.rules()).hasSize(1); RulesDefinition.Rule customRule = repository.rule(RULE_KEY); assertThat(customRule).isNotNull(); assertThat(customRule.key()).isEqualTo(RULE_KEY); assertThat(customRule.name()).isEqualTo(RULE_NAME); RulesDefinition.Param param = repository.rules().get(0).params().get(0); assertThat(param.key()).isEqualTo("customParam"); assertThat(param.description()).isEqualTo("Custom parameter"); assertThat(param.defaultValue()).isEqualTo("Default value"); }
### Question: CustomCssRulesDefinition implements CustomRulesDefinition { @Override public void define(Context context) { NewRepository repo = context.createRepository(repositoryKey(), "css").setName(repositoryName()); new AnnotationBasedRulesDefinition(repo, "css").addRuleClasses(false, ImmutableList.copyOf(checkClasses())); repo.done(); } @Override void define(Context context); }### Answer: @Test public void test() { MyCustomCssRulesDefinition rulesDefinition = new MyCustomCssRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository(REPOSITORY_KEY); assertThat(repository.name()).isEqualTo(REPOSITORY_NAME); assertThat(repository.language()).isEqualTo("css"); assertThat(repository.rules()).hasSize(1); RulesDefinition.Rule customRule = repository.rule(RULE_KEY); assertThat(customRule).isNotNull(); assertThat(customRule.key()).isEqualTo(RULE_KEY); assertThat(customRule.name()).isEqualTo(RULE_NAME); RulesDefinition.Param param = repository.rules().get(0).params().get(0); assertThat(param.key()).isEqualTo("customParam"); assertThat(param.description()).isEqualTo("Custom parameter"); assertThat(param.defaultValue()).isEqualTo("Default value"); }
### Question: LessAnalyzerSensor extends AbstractLanguageAnalyzerSensor { @Override public void describe(SensorDescriptor descriptor) { descriptor .onlyOnLanguage(LessLanguage.KEY) .name("Less Analyzer Sensor") .onlyOnFileType(Type.MAIN); } LessAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter); LessAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter, @Nullable CustomLessRulesDefinition[] customRulesDefinition); @Override void describe(SensorDescriptor descriptor); @Override String analyzerName(); @Override String language(); @Override ActionParser<Tree> parser(FileSystem fileSystem); @Override List<InputFile> filesToAnalyze(FileSystem fileSystem); @Override Checks checks(CheckFactory checkFactory, CustomRulesDefinition[] customRulesDefinitions); @Override List<TreeVisitor> treeVisitors(SensorContext sensorContext, Checks checks, NoSonarFilter noSonarFilter); @Override Class parsingErrorCheck(); }### Answer: @Test public void should_create_a_valid_sensor_descriptor() { DefaultSensorDescriptor descriptor = new DefaultSensorDescriptor(); createLessSquidSensor().describe(descriptor); assertThat(descriptor.name()).isEqualTo("Less Analyzer Sensor"); assertThat(descriptor.languages()).containsOnly("less"); assertThat(descriptor.type()).isEqualTo(InputFile.Type.MAIN); }
### Question: CustomLessRulesDefinition implements CustomRulesDefinition { @Override public void define(Context context) { NewRepository repo = context.createRepository(repositoryKey(), "less").setName(repositoryName()); new AnnotationBasedRulesDefinition(repo, "less").addRuleClasses(false, ImmutableList.copyOf(checkClasses())); repo.done(); } @Override void define(Context context); }### Answer: @Test public void test() { MyCustomLessRulesDefinition rulesDefinition = new MyCustomLessRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository(REPOSITORY_KEY); assertThat(repository.name()).isEqualTo(REPOSITORY_NAME); assertThat(repository.language()).isEqualTo("less"); assertThat(repository.rules()).hasSize(1); RulesDefinition.Rule customRule = repository.rule(RULE_KEY); assertThat(customRule).isNotNull(); assertThat(customRule.key()).isEqualTo(RULE_KEY); assertThat(customRule.name()).isEqualTo(RULE_NAME); RulesDefinition.Param param = repository.rules().get(0).params().get(0); assertThat(param.key()).isEqualTo("customParam"); assertThat(param.description()).isEqualTo("Custom parameter"); assertThat(param.defaultValue()).isEqualTo("Default value"); }
### Question: LessCommentAnalyser extends CssCommentAnalyser { @Override public String getContents(String comment) { if (comment.startsWith("/*")) { return comment.substring(2, comment.length() - 2); } else if (comment.startsWith("<!--")) { return comment.substring(4, comment.length() - 3); } else if (comment.startsWith(" return comment.substring(2, comment.length()); } else { throw new IllegalArgumentException("Unknown Less comment type"); } } @Override String getContents(String comment); }### Answer: @Test public void content() { assertThat(analyser.getContents("")).isEqualTo("comment"); assertThat(analyser.getContents("")).isEqualTo(" comment "); assertThat(analyser.getContents("<!--comment-->")).isEqualTo("comment"); assertThat(analyser.getContents("<!-- comment -->")).isEqualTo(" comment "); assertThat(analyser.getContents(" assertThat(analyser.getContents(" } @Test(expected = IllegalArgumentException.class) public void unknown_type_of_comments() { analyser.getContents(""); }
### Question: ScssCommentAnalyser extends CssCommentAnalyser { @Override public String getContents(String comment) { if (comment.startsWith("/*")) { return comment.substring(2, comment.length() - 2); } else if (comment.startsWith(" return comment.substring(2, comment.length()); } else { throw new IllegalArgumentException("Unknown SCSS comment type"); } } @Override String getContents(String comment); }### Answer: @Test public void content() { assertThat(analyser.getContents("")).isEqualTo("comment"); assertThat(analyser.getContents("")).isEqualTo(" comment "); assertThat(analyser.getContents(" assertThat(analyser.getContents(" } @Test(expected = IllegalArgumentException.class) public void unknown_type_of_comments() { analyser.getContents(""); }
### Question: CssCommentAnalyser extends CommentAnalyser { @Override public String getContents(String comment) { if (comment.startsWith("/*")) { return comment.substring(2, comment.length() - 2); } else if (comment.startsWith("<!--")) { return comment.substring(4, comment.length() - 3); } else { throw new IllegalArgumentException(); } } @Override boolean isBlank(String line); @Override String getContents(String comment); }### Answer: @Test public void content() { assertThat(analyser.getContents("")).isEqualTo("comment"); assertThat(analyser.getContents("")).isEqualTo(" comment "); assertThat(analyser.getContents("<!--comment-->")).isEqualTo("comment"); assertThat(analyser.getContents("<!-- comment -->")).isEqualTo(" comment "); } @Test(expected = IllegalArgumentException.class) public void unknown_type_of_comments() { analyser.getContents(""); }
### Question: CssCommentAnalyser extends CommentAnalyser { @Override public boolean isBlank(String line) { for (int i = 0; i < line.length(); i++) { if (Character.isLetterOrDigit(line.charAt(i))) { return false; } } return true; } @Override boolean isBlank(String line); @Override String getContents(String comment); }### Answer: @Test public void blank() { assertThat(analyser.isBlank(" ")).isTrue(); assertThat(analyser.isBlank(" ")).isTrue(); }
### Question: LessRulesDefinition implements RulesDefinition { @Override public void define(Context context) { NewRepository repository = context .createRepository(CheckList.LESS_REPOSITORY_KEY, LessLanguage.KEY) .setName(CheckList.LESS_REPOSITORY_NAME); new AnnotationBasedRulesDefinition(repository, LessLanguage.KEY).addRuleClasses(false, CheckList.getLessChecks()); repository.done(); } @Override void define(Context context); }### Answer: @Test public void test() { LessRulesDefinition rulesDefinition = new LessRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository("less"); assertThat(repository.name()).isEqualTo("SonarQube"); assertThat(repository.language()).isEqualTo("less"); assertThat(repository.rules()).hasSize(89); RulesDefinition.Rule rule = repository.rule(DeprecatedEscapingFunctionCheck.class.getAnnotation(Rule.class).key()); assertThat(rule).isNotNull(); assertThat(rule.name()).isEqualTo(DeprecatedEscapingFunctionCheck.class.getAnnotation(Rule.class).name()); }
### Question: LessLanguage extends AbstractLanguage { @Override public String[] getFileSuffixes() { String[] suffixes = settings.getStringArray(Plugin.LESS_FILE_SUFFIXES_KEY); if (suffixes == null \|\| suffixes.length == 0) { suffixes = StringUtils.split(Plugin.LESS_FILE_SUFFIXES_DEFAULT_VALUE, ","); } return suffixes; } LessLanguage(Settings settings); @Override String[] getFileSuffixes(); static final String KEY; static final String NAME; }### Answer: @Test public void default_file_suffix() { LessLanguage language = new LessLanguage(mock(Settings.class)); assertThat(language.getFileSuffixes()).containsOnly("less"); } @Test public void custom_file_suffixes() { Settings settings = new Settings(); settings.setProperty("sonar.less.file.suffixes", "less,less3"); LessLanguage language = new LessLanguage(settings); assertThat(language.getFileSuffixes()).containsOnly("less", "less3"); }
### Question: StandardAtRuleFactory { public static StandardAtRule getByName(String atRuleName) { StandardAtRule standardAtRule = ALL.get(atRuleName.toLowerCase(Locale.ENGLISH)); return standardAtRule != null ? standardAtRule : new UnknownAtRule(atRuleName); } private StandardAtRuleFactory(); static StandardAtRule getByName(String atRuleName); static List<StandardAtRule> getAll(); }### Answer: @Test public void should_return_a_valid_charset_at_rule_object() { StandardAtRule atRule = StandardAtRuleFactory.getByName("charset"); assertEquals(Charset.class, atRule.getClass()); assertEquals("charset", atRule.getName()); assertEquals(1, atRule.getLinks().size()); assertEquals("https: assertFalse(atRule.isObsolete()); assertFalse(atRule.isExperimental()); } @Test public void should_return_a_valid_charset_at_rule_object_uppercase_test() { StandardAtRule atRule = StandardAtRuleFactory.getByName("CHARSET"); assertEquals(Charset.class, atRule.getClass()); assertEquals("charset", atRule.getName()); assertEquals(1, atRule.getLinks().size()); assertEquals("https: assertFalse(atRule.isObsolete()); assertFalse(atRule.isExperimental()); } @Test public void should_return_a_valid_character_variant_at_rule_object() { StandardAtRule atRule = StandardAtRuleFactory.getByName("character-variant"); assertEquals(CharacterVariant.class, atRule.getClass()); assertEquals("character-variant", atRule.getName()); assertEquals(2, atRule.getLinks().size()); assertEquals("https: assertEquals("https: assertFalse(atRule.isObsolete()); assertTrue(atRule.isExperimental()); } @Test public void should_return_a_valid_keyframes_at_rule_object() { StandardAtRule atRule = StandardAtRuleFactory.getByName("keyframes"); assertEquals(Keyframes.class, atRule.getClass()); assertEquals("keyframes", atRule.getName()); assertEquals(1, atRule.getLinks().size()); assertFalse(atRule.isObsolete()); assertFalse(atRule.isExperimental()); }
### Question: StandardAtRuleFactory { public static List<StandardAtRule> getAll() { return new ArrayList<>(ALL.values()); } private StandardAtRuleFactory(); static StandardAtRule getByName(String atRuleName); static List<StandardAtRule> getAll(); }### Answer: @Test public void number_of_standard_at_rules() { assertEquals(37, StandardAtRuleFactory.getAll().size()); } @Test public void number_of_experimental_standard_at_rules() { assertEquals( 29, StandardAtRuleFactory.getAll() .stream() .filter(StandardAtRule::isExperimental) .collect(Collectors.toList()) .size()); } @Test public void number_of_obsolete_standard_at_rules() { assertEquals( 0, StandardAtRuleFactory.getAll() .stream() .filter(StandardAtRule::isObsolete) .collect(Collectors.toList()) .size()); }
### Question: ScssAnalyzerSensor extends AbstractLanguageAnalyzerSensor { @Override public void describe(SensorDescriptor descriptor) { descriptor .onlyOnLanguage(ScssLanguage.KEY) .name("SCSS Analyzer Sensor") .onlyOnFileType(Type.MAIN); } ScssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter); ScssAnalyzerSensor(FileSystem fileSystem, CheckFactory checkFactory, Settings settings, NoSonarFilter noSonarFilter, @Nullable CustomScssRulesDefinition[] customRulesDefinition); @Override void describe(SensorDescriptor descriptor); @Override String analyzerName(); @Override String language(); @Override ActionParser<Tree> parser(FileSystem fileSystem); @Override List<InputFile> filesToAnalyze(FileSystem fileSystem); @Override Checks checks(CheckFactory checkFactory, CustomRulesDefinition[] customRulesDefinitions); @Override List<TreeVisitor> treeVisitors(SensorContext sensorContext, Checks checks, NoSonarFilter noSonarFilter); @Override Class parsingErrorCheck(); }### Answer: @Test public void should_create_a_valid_sensor_descriptor() { DefaultSensorDescriptor descriptor = new DefaultSensorDescriptor(); createScssSquidSensor().describe(descriptor); assertThat(descriptor.name()).isEqualTo("SCSS Analyzer Sensor"); assertThat(descriptor.languages()).containsOnly("scss"); assertThat(descriptor.type()).isEqualTo(InputFile.Type.MAIN); }
### Question: StandardFunctionFactory { public static List<StandardFunction> getAll() { return new ArrayList<>(ALL.values()); } private StandardFunctionFactory(); static StandardFunction getByName(String functionName); static List<StandardFunction> getAll(); }### Answer: @Test public void number_of_standard_css_functions() { assertEquals(154, StandardFunctionFactory.getAll().stream().filter(StandardFunction::isCss).count()); } @Test public void number_of_standard_less_functions() { assertEquals(83, StandardFunctionFactory.getAll().stream().filter(StandardFunction::isLess).count()); } @Test public void number_of_obsolete_functions() { assertEquals(71, StandardFunctionFactory.getAll().stream().filter(StandardFunction::isObsolete).count()); } @Test public void number_of_experimental_functions() { assertEquals(13, StandardFunctionFactory.getAll().stream().filter(StandardFunction::isExperimental).count()); }
### Question: StandardPseudoIdentifierFactory { public static StandardPseudoIdentifier getByName(String identifier) { StandardPseudoIdentifier standardPseudoIdentifier = ALL.get(identifier.toLowerCase(Locale.ENGLISH)); return standardPseudoIdentifier != null ? standardPseudoIdentifier : new UnknownPseudoIdentifier(identifier); } private StandardPseudoIdentifierFactory(); static StandardPseudoIdentifier getByName(String identifier); static List<StandardPseudoIdentifier> getAll(); }### Answer: @Test public void should_return_a_valid_first_line_identifier_function_object() { StandardPseudoIdentifier identifier = StandardPseudoIdentifierFactory.getByName("first-line"); assertEquals(FirstLine.class, identifier.getClass()); assertEquals("first-line", identifier.getName()); assertEquals(1, identifier.getLinks().size()); assertEquals("https: assertFalse(identifier.isExperimental()); assertFalse(identifier.isObsolete()); } @Test public void should_return_a_valid_first_line_pseudo_identifier_object_uppercase_test() { StandardPseudoIdentifier identifier = StandardPseudoIdentifierFactory.getByName("FIRST-LINE"); assertEquals(FirstLine.class, identifier.getClass()); assertEquals("first-line", identifier.getName()); assertEquals(1, identifier.getLinks().size()); assertEquals("https: assertFalse(identifier.isExperimental()); assertFalse(identifier.isObsolete()); } @Test public void should_return_a_valid_first_line_pseudo_identifier_object_mix_uppercase_lowercase_test() { StandardPseudoIdentifier identifier = StandardPseudoIdentifierFactory.getByName("FIRSt-LINE"); assertEquals(FirstLine.class, identifier.getClass()); assertEquals("first-line", identifier.getName()); assertEquals(1, identifier.getLinks().size()); assertEquals("https: assertFalse(identifier.isExperimental()); assertFalse(identifier.isObsolete()); }
### Question: ScssRulesDefinition implements RulesDefinition { @Override public void define(Context context) { NewRepository repository = context .createRepository(CheckList.SCSS_REPOSITORY_KEY, ScssLanguage.KEY) .setName(CheckList.SCSS_REPOSITORY_NAME); new AnnotationBasedRulesDefinition(repository, ScssLanguage.KEY).addRuleClasses(false, CheckList.getScssChecks()); repository.done(); } @Override void define(Context context); }### Answer: @Test public void test() { ScssRulesDefinition rulesDefinition = new ScssRulesDefinition(); RulesDefinition.Context context = new RulesDefinition.Context(); rulesDefinition.define(context); RulesDefinition.Repository repository = context.repository("scss"); assertThat(repository.name()).isEqualTo("SonarQube"); assertThat(repository.language()).isEqualTo("scss"); assertThat(repository.rules()).hasSize(100); RulesDefinition.Rule rule = repository.rule(ScssVariableNamingConventionCheck.class.getAnnotation(Rule.class).key()); assertThat(rule).isNotNull(); assertThat(rule.name()).isEqualTo(ScssVariableNamingConventionCheck.class.getAnnotation(Rule.class).name()); }
### Question: StandardPseudoIdentifierFactory { public static List<StandardPseudoIdentifier> getAll() { return new ArrayList<>(ALL.values()); } private StandardPseudoIdentifierFactory(); static StandardPseudoIdentifier getByName(String identifier); static List<StandardPseudoIdentifier> getAll(); }### Answer: @Test public void number_of_standard_pseudo_identifiers() { assertEquals(59, StandardPseudoIdentifierFactory.getAll().size()); } @Test public void number_of_obsolete_pseudo_identifiers() { assertEquals(1, StandardPseudoIdentifierFactory.getAll().stream().filter(StandardPseudoIdentifier::isObsolete).count()); } @Test public void number_of_experimental_pseudo_identifiers() { assertEquals(31, StandardPseudoIdentifierFactory.getAll().stream().filter(StandardPseudoIdentifier::isExperimental).count()); }
### Question: StandardPseudoFunctionFactory { public static StandardPseudoFunction getByName(String functionName) { StandardPseudoFunction standardPseudoFunction = ALL.get(functionName.toLowerCase(Locale.ENGLISH)); return standardPseudoFunction != null ? standardPseudoFunction : new UnknownPseudoFunction(functionName); } private StandardPseudoFunctionFactory(); static StandardPseudoFunction getByName(String functionName); static List<StandardPseudoFunction> getAll(); }### Answer: @Test public void should_return_a_valid_has_pseudo_function_object() { StandardPseudoFunction function = StandardPseudoFunctionFactory.getByName("has"); assertEquals(Has.class, function.getClass()); assertEquals("has", function.getName()); assertEquals(1, function.getLinks().size()); assertEquals("https: assertTrue(function.isExperimental()); assertFalse(function.isObsolete()); } @Test public void should_return_a_valid_has_pseudo_function_object_uppercase_test() { StandardPseudoFunction function = StandardPseudoFunctionFactory.getByName("HAS"); assertEquals(Has.class, function.getClass()); assertEquals("has", function.getName()); assertEquals(1, function.getLinks().size()); assertEquals("https: assertTrue(function.isExperimental()); assertFalse(function.isObsolete()); } @Test public void should_return_a_valid_has_pseudo_function_object_mix_uppercase_lowercase_test() { StandardPseudoFunction function = StandardPseudoFunctionFactory.getByName("HaS"); assertEquals(Has.class, function.getClass()); assertEquals("has", function.getName()); assertEquals(1, function.getLinks().size()); assertEquals("https: assertTrue(function.isExperimental()); assertFalse(function.isObsolete()); }
### Question: StandardPseudoFunctionFactory { public static List<StandardPseudoFunction> getAll() { return new ArrayList<>(ALL.values()); } private StandardPseudoFunctionFactory(); static StandardPseudoFunction getByName(String functionName); static List<StandardPseudoFunction> getAll(); }### Answer: @Test public void number_of_standard_pseudo_functions() { assertEquals(19, StandardPseudoFunctionFactory.getAll().size()); } @Test public void number_of_obsolete_pseudo_functions() { assertEquals(1, StandardPseudoFunctionFactory.getAll().stream().filter(StandardPseudoFunction::isObsolete).count()); } @Test public void number_of_experimental_pseudo_functions() { assertEquals(10, StandardPseudoFunctionFactory.getAll().stream().filter(StandardPseudoFunction::isExperimental).count()); }
### Question: ScssLanguage extends AbstractLanguage { @Override public String[] getFileSuffixes() { String[] suffixes = settings.getStringArray(Plugin.SCSS_FILE_SUFFIXES_KEY); if (suffixes == null \|\| suffixes.length == 0) { suffixes = StringUtils.split(Plugin.SCSS_FILE_SUFFIXES_DEFAULT_VALUE, ","); } return suffixes; } ScssLanguage(Settings settings); @Override String[] getFileSuffixes(); static final String KEY; static final String NAME; }### Answer: @Test public void default_file_suffix() { ScssLanguage language = new ScssLanguage(mock(Settings.class)); assertThat(language.getFileSuffixes()).containsOnly("scss"); } @Test public void custom_file_suffixes() { Settings settings = new Settings(); settings.setProperty("sonar.scss.file.suffixes", "scss,scss3"); ScssLanguage language = new ScssLanguage(settings); assertThat(language.getFileSuffixes()).containsOnly("scss", "scss3"); }
### Question: StandardPseudoComponentFactory { public static List<? extends StandardPseudoComponent> getAll() { return Stream .concat(StandardPseudoIdentifierFactory.getAll().stream(), StandardPseudoFunctionFactory.getAll().stream()) .collect(Collectors.toList()); } private StandardPseudoComponentFactory(); static List<? extends StandardPseudoComponent> getAll(); }### Answer: @Test public void number_of_standard_pseudo_components() { assertEquals(78, StandardPseudoComponentFactory.getAll().size()); }
### Question: ExperimentalNotLessFunctionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFunctionsToExclude(String functionsToExclude) { this.functionsToExclude = functionsToExclude; } @Override void visitFunction(FunctionTree tree); @Override void validateParameters(); }### Answer: @Test public void test_exclude_functions() { ExperimentalNotLessFunctionCheck check = new ExperimentalNotLessFunctionCheck(); check.setFunctionsToExclude("conic-gradient\|count.*"); CssCheckVerifier.verifyLessFile(check, CheckTestUtils.getLessTestFile("experimentalFunctionUsageExcludeFunctions.less")); } @Test public void should_throw_an_illegal_state_exception_as_the_functionsToExclude_parameter_is_not_valid() { try { ExperimentalNotLessFunctionCheck check = new ExperimentalNotLessFunctionCheck(); check.setFunctionsToExclude("("); CssCheckVerifier.issuesOnLessFile(check, CheckTestUtils.getLessTestFile("experimentalFunctionUsage.less")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check less:experimental-not-less-function-usage (Experimental functions should not be used): " + "functionsToExclude parameter \"(\" is not a valid regular expression."); } }
### Question: LessVariableNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitLessVariableDeclaration(LessVariableDeclarationTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyLessFile(check, CheckTestUtils.getLessTestFile("lessVariableNamingConvention.less")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyLessFile(check, CheckTestUtils.getLessTestFile("lessVariableNamingConventionCustomFormat.less")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnLessFile(check, CheckTestUtils.getLessTestFile("lessVariableNamingConvention.less")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check less:less-variable-naming-convention (Less variables should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: NestedRulesetsCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setMax(int max) { this.max = max; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void visitRuleset(RulesetTree tree); }### Answer: @Test public void test_with_custom_threshold() { NestedRulesetsCheck check = new NestedRulesetsCheck(); check.setMax(2); CssCheckVerifier.verifyLessFile(check, CheckTestUtils.getLessTestFile("nestedRulesets/nestedRulesetsCustomThreshold.less")); } @Test public void test_with_custom_threshold() { NestedRulesetsCheck check = new NestedRulesetsCheck(); check.setMax(2); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("nested-rulesets/nestedRulesetsCustomThreshold.scss")); }
### Question: TooComplexConditionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setMax(int max) { this.max = max; } @Override void visitScssCondition(ScssConditionTree tree); }### Answer: @Test public void test_custom_threshold() { TooComplexConditionCheck check = new TooComplexConditionCheck(); check.setMax(4); CssCheckVerifier.verifyScssFile( check, CheckTestUtils.getScssTestFile("too-complex-condition/tooComplexConditionCustom.scss")); }
### Question: CustomFunctionNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitScssFunction(ScssFunctionTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("custom-function-naming-convention/customFunctionNamingConvention.scss")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("custom-function-naming-convention/customFunctionNamingConventionCustomFormat.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnScssFile(check, CheckTestUtils.getScssTestFile("custom-function-naming-convention/customFunctionNamingConvention.scss")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check scss:custom-function-naming-convention (Custom functions should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: PlaceholderSelectorNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitScssPlaceholderSelector(ScssPlaceholderSelectorTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, getTestFile("selectorNamingConvention.scss")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyScssFile(check, getTestFile("selectorNamingConventionCustomFormat.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnScssFile(check, CheckTestUtils.getCommonTestFile("selectorNamingConvention/selectorNamingConvention.css")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check scss:placeholder-selector-naming-convention (Placeholder selectors should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: MixinNamingConventionCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setFormat(String format) { this.format = format; } @Override void visitScssMixin(ScssMixinTree tree); @Override void validateParameters(); }### Answer: @Test public void test_with_default_format() { check.setFormat("^[a-z][-a-z0-9]*$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("mixin-naming-convention/mixinNamingConvention.scss")); } @Test public void test_with_custom_format() { check.setFormat("^[-a-z]+$"); CssCheckVerifier.verifyScssFile(check, CheckTestUtils.getScssTestFile("mixin-naming-convention/mixinNamingConventionCustomFormat.scss")); } @Test public void should_throw_an_illegal_state_exception_as_the_format_parameter_is_not_valid() { try { check.setFormat("("); CssCheckVerifier.issuesOnScssFile(check, CheckTestUtils.getScssTestFile("mixin-naming-convention/mixinNamingConvention.scss")).noMore(); } catch (IllegalStateException e) { assertThat(e.getMessage()).isEqualTo("Check scss:mixin-naming-convention (Mixins should follow a naming convention): " + "format parameter \"(\" is not a valid regular expression."); } }
### Question: NestedControlFlowDirectivesCheck extends DoubleDispatchVisitorCheck { @VisibleForTesting void setMax(int max) { this.max = max; } @Override void visitStyleSheet(StyleSheetTree tree); @Override void visitScssIf(ScssIfTree tree); @Override void visitScssElseIf(ScssElseIfTree tree); @Override void visitScssElse(ScssElseTree tree); @Override void visitScssFor(ScssForTree tree); @Override void visitScssWhile(ScssWhileTree tree); @Override void visitScssEach(ScssEachTree tree); }### Answer: @Test public void test_with_custom_format() { NestedControlFlowDirectivesCheck check = new NestedControlFlowDirectivesCheck(); check.setMax(2); CssCheckVerifier.verifyScssFile( check, CheckTestUtils.getScssTestFile("nested-control-flow-directives/nestedControlFlowDirectivesCustomThreshold.scss")); }
### Question: ScssProfile extends ProfileDefinition { @Override public RulesProfile createProfile(ValidationMessages messages) { AnnotationBasedProfileBuilder annotationBasedProfileBuilder = new AnnotationBasedProfileBuilder(ruleFinder); return annotationBasedProfileBuilder.build( CheckList.SCSS_REPOSITORY_KEY, SONARQUBE_WAY_PROFILE_NAME, ScssLanguage.KEY, CheckList.getScssChecks(), messages); } ScssProfile(RuleFinder ruleFinder); @Override RulesProfile createProfile(ValidationMessages messages); static final String SONARQUBE_WAY_PROFILE_NAME; }### Answer: @Test public void should_create_sonarqube_way_profile() { ValidationMessages validation = ValidationMessages.create(); ScssProfile definition = new ScssProfile(universalRuleFinder()); RulesProfile profile = definition.createProfile(validation); assertThat(profile.getName()).isEqualTo("SonarQube Way"); assertThat(profile.getLanguage()).isEqualTo("scss"); assertThat(profile.getActiveRulesByRepository("scss")).hasSize(84); assertThat(validation.hasErrors()).isFalse(); }
### Question: SizeUnitTypeAdapter extends TypeAdapter<SizeUnit> { @Override public void write(final JsonWriter out, final SizeUnit value) throws IOException { out.value(value.toString().toLowerCase(Locale.US)); } @Override void write(final JsonWriter out, final SizeUnit value); @Override SizeUnit read(final JsonReader in); }### Answer: @Test public void write() throws IOException { final JsonWriter writer = mock(JsonWriter.class); this.typeAdapter.write(writer, SizeUnit.BYTES); verify(writer).value("bytes"); }
### Question: ReadObjectNameFunction implements Function<Map<String, String>, String> { @Override public String apply(final Map<String, String> context) { final ObjectMetadata objectMetadata = this.objectManager.get(); context.put(Context.X_OG_OBJECT_NAME, objectMetadata.getName()); context.put(Context.X_OG_OBJECT_SIZE, String.valueOf(objectMetadata.getSize())); context.put(Context.X_OG_CONTAINER_SUFFIX, String.valueOf(objectMetadata.getContainerSuffix())); context.put(Context.X_OG_LEGAL_HOLD_SUFFIX, String.valueOf(objectMetadata.getNumberOfLegalHolds())); context.put(Context.X_OG_OBJECT_RETENTION, String.valueOf(objectMetadata.getRetention())); return objectMetadata.getName(); } ReadObjectNameFunction(final ObjectManager objectManager); @Override String apply(final Map<String, String> context); @Override String toString(); }### Answer: @Test public void readObjectNameSupplier() { final String object = "objectName"; final ObjectMetadata objectName = mock(ObjectMetadata.class); when(objectName.getName()).thenReturn(object); when(this.objectManager.get()).thenReturn(objectName); final Map<String, String> context = Maps.newHashMap(); assertThat(new ReadObjectNameFunction(this.objectManager).apply(context), is(object)); assertThat(context.get(Context.X_OG_OBJECT_NAME), is(object)); } @Test(expected = ObjectManagerException.class) public void supplierException() { when(this.objectManager.get()).thenThrow(new ObjectManagerException()); new ReadObjectNameFunction(this.objectManager).apply(Maps.<String, String>newHashMap()); }
### Question: ThrottledInputStream extends FilterInputStream { private void throttle(final int bytes) { if (bytes == 1) { this.rateLimiter.acquire(); } else if (bytes > 1) { this.rateLimiter.acquire(bytes - 1); this.rateLimiter.acquire(); } } ThrottledInputStream(final InputStream in, final long bytesPerSecond); @Override int read(); @Override int read(final byte[] b); @Override int read(final byte[] b, final int off, final int len); @Override String toString(); }### Answer: @Test @UseDataProvider("provideInvalidThrottleInputStream") public void invalidInputStream(final InputStream in, final long bytesPerSecond, final Class<Exception> expectedException) { this.thrown.expect(expectedException); Streams.throttle(in, bytesPerSecond); }
### Question: Suppliers { public static <T> Supplier<T> of(final T value) { checkNotNull(value); return new Supplier<T>() { @Override public T get() { return value; } @Override public String toString() { return value.toString(); } }; } private Suppliers(); static Supplier<T> of(final T value); static Supplier<T> cycle(final List<T> values); static Supplier<Long> cycle(final long minValue, final long maxValue); static RandomSupplier.Builder<T> random(); static Supplier<Long> random(final long minValue, final long maxValue); }### Answer: @Test(expected = NullPointerException.class) public void nullOf() { Suppliers.of(null); } @Test public void of() { final Supplier<Integer> s = Suppliers.of(1); for (int i = 0; i < 10; i++) { assertThat(s.get(), is(1)); } }
### Question: Suppliers { public static <T> RandomSupplier.Builder<T> random() { return new RandomSupplier.Builder<T>(); } private Suppliers(); static Supplier<T> of(final T value); static Supplier<T> cycle(final List<T> values); static Supplier<Long> cycle(final long minValue, final long maxValue); static RandomSupplier.Builder<T> random(); static Supplier<Long> random(final long minValue, final long maxValue); }### Answer: @Test(expected = IllegalArgumentException.class) public void randomNegativeMinValue() { Suppliers.random(-1, 100); } @Test(expected = IllegalArgumentException.class) public void randomMaxValueLessThanMinValue() { Suppliers.random(10, 9); }
### Question: ThrottledInputStream extends FilterInputStream { @Override public int read() throws IOException { final int b = super.read(); if (b > -1) { throttle(1); } return b; } ThrottledInputStream(final InputStream in, final long bytesPerSecond); @Override int read(); @Override int read(final byte[] b); @Override int read(final byte[] b, final int off, final int len); @Override String toString(); }### Answer: @Test public void readOneByteAtATime() throws IOException { final InputStream in = new ThrottledInputStream(Streams.create(this.body), 1000); final long timestampStart = System.nanoTime(); for (int i = 0; i < 100; i++) { in.read(); } final long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - timestampStart); final long delta = Math.abs(duration - 100); assertThat(delta, lessThan(15L)); } @Test public void read() throws IOException { final InputStream in = new ThrottledInputStream(Streams.create(this.body), 1000); final long timestampStart = System.nanoTime(); in.read(new byte[100]); final long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - timestampStart); final long delta = Math.abs(duration - 100); assertThat(delta, lessThan(15L)); }
### Question: DeleteObjectNameFunction implements Function<Map<String, String>, String> { @Override public String apply(final Map<String, String> context) { final ObjectMetadata objectMetadata = this.objectManager.removeForUpdate(); context.put(Context.X_OG_OBJECT_NAME, objectMetadata.getName()); context.put(Context.X_OG_OBJECT_SIZE, String.valueOf(objectMetadata.getSize())); context.put(Context.X_OG_CONTAINER_SUFFIX, String.valueOf(objectMetadata.getContainerSuffix())); return objectMetadata.getName(); } DeleteObjectNameFunction(final ObjectManager objectManager); @Override String apply(final Map<String, String> context); @Override String toString(); }### Answer: @Test public void deleteObjectNameSupplier() { final String object = "objectName"; final ObjectMetadata objectName = mock(ObjectMetadata.class); when(objectName.getName()).thenReturn(object); when(this.objectManager.removeForUpdate()).thenReturn(objectName); final Map<String, String> context = Maps.newHashMap(); assertThat(new DeleteObjectNameFunction(this.objectManager).apply(context), is(object)); assertThat(context.get(Context.X_OG_OBJECT_NAME), is(object)); } @Test(expected = ObjectManagerException.class) public void supplierException() { when(this.objectManager.removeForUpdate()).thenThrow(new ObjectManagerException()); new DeleteObjectNameFunction(this.objectManager).apply(Maps.<String, String>newHashMap()); }
### Question: RandomPercentageSupplier implements Supplier<T> { @Override public T get() { final double totalPercent = getCurrentPercents(); final double rnd = this.random.nextDouble() * totalPercent; double previousPercents = 0.0; RandomPercentageSupplier.Choice<T> unUsedChoice = this.choices.get(this.choices.size()-1); for (final RandomPercentageSupplier.Choice<T> choice : this.choices) { if (rnd < previousPercents + choice.currentPercentage) { if (choice.value != null) { return choice.value; } else { return null; } } previousPercents += choice.currentPercentage; } throw new IllegalStateException("Incorrect percentage calculation"); } private RandomPercentageSupplier(final RandomPercentageSupplier.Builder<T> builder); @Override T get(); @Override String toString(); }### Answer: @Test public void oneChoice() { final Supplier<Integer> s = new RandomPercentageSupplier.Builder<Integer>().withChoice(1, 100.00).build(); int count = 0; for (int i = 0; i < 100; i++) { Integer val = s.get(); if (val != null && val == 1) { count++; } } assertThat(count, comparesEqualTo(100)); } @Test public void multipleChoices() { final Supplier<Integer> s = new RandomPercentageSupplier.Builder<Integer>().withChoice(1, 25.0).withChoice(2, 25.0) .withChoice(3, 25.0).withRandom(new Random()).build(); final Map<Integer, Integer> counts = Maps.newHashMap(); counts.put(1, 0); counts.put(2, 0); counts.put(3, 0); for (int i = 0; i < 100; i++) { final Integer value = s.get(); if (value != null) { counts.put(value, counts.get(value) + 1); } } for (final int count : counts.values()) { assertThat(count, greaterThan(0)); } }
### Question: KeystoneAuth implements HttpAuth { @Override public AuthenticatedRequest authenticate(final Request request) { final String keystoneToken = checkNotNull(request.getContext().get(Context.X_OG_KEYSTONE_TOKEN)); final AuthenticatedHttpRequest authenticatedRequest = new AuthenticatedHttpRequest(request); authenticatedRequest.addHeader("X-Auth-Token", keystoneToken); return authenticatedRequest; } @Override AuthenticatedRequest authenticate(final Request request); @Override String toString(); }### Answer: @Test(expected = RuntimeException.class) public void noToken() { final Request badRequest = new HttpRequest.Builder(Method.PUT, this.uri, Operation.WRITE).build(); this.keystoneAuth.authenticate(badRequest); }
### Question: ApacheClient implements Client { @Override public ListenableFuture<Integer> shutdown(final boolean immediate, final int timeout) { final SettableFuture<Integer> future = SettableFuture.create(); final Thread t = new Thread(getShutdownRunnable(future, immediate, timeout)); t.setName("client-shutdown"); this.running = false; t.start(); return future; } private ApacheClient(final Builder builder); @Override ListenableFuture<Response> execute(final Request request); @Override ListenableFuture<Integer> shutdown(final boolean immediate, final int timeout); @Override String toString(); }### Answer: @Test public void positiveMaxIdleTime() { new ApacheClient.Builder().withMaxIdleTime(100).build().shutdown(true, 0); }
### Question: PoissonRequestRateScheduler implements Scheduler { double requestsPerSecond(final double rate, final TimeUnit unit) { return rate / (unit.toNanos(1) / (double) TimeUnit.SECONDS.toNanos(1)); } PoissonRequestRateScheduler(final double rate, final TimeUnit unit, final double rampup, final TimeUnit rampupUnit); @Override void schedule(); @Override void complete(); @Override String toString(); }### Answer: @Test @UseDataProvider("providePoissonRequestsPerSecond") public void requestsPerSecond(final double rate, final TimeUnit unit, final double expectedRequestsPerSecond) { final PoissonRequestRateScheduler s = new PoissonRequestRateScheduler(1.0, TimeUnit.SECONDS, 0.0, TimeUnit.SECONDS); assertThat(s.requestsPerSecond(rate, unit), closeTo(expectedRequestsPerSecond, Math.pow(0.1, 6))); }
### Question: RequestRateScheduler implements Scheduler { double requestsPerSecond(final double rate, final TimeUnit unit) { return rate / (unit.toNanos(1) / (double) TimeUnit.SECONDS.toNanos(1)); } RequestRateScheduler(final double rate, final TimeUnit unit, final double rampup, final TimeUnit rampupUnit); @Override void schedule(); @Override void complete(); @Override String toString(); }### Answer: @Test @UseDataProvider("provideRequestsPerSecond") public void requestsPerSecond(final double rate, final TimeUnit unit, final double expectedRequestsPerSecond) { final RequestRateScheduler s = new RequestRateScheduler(1.0, TimeUnit.SECONDS, 0.0, TimeUnit.SECONDS); assertThat(s.requestsPerSecond(rate, unit), closeTo(expectedRequestsPerSecond, Math.pow(0.1, 6))); }
### Question: LegacyObjectMetadata implements ObjectMetadata { public static LegacyObjectMetadata fromBytes(final byte[] objectBytes) { checkNotNull(objectBytes); checkArgument(objectBytes.length == OBJECT_SIZE, String.format("objectName length must be == %s", OBJECT_SIZE) + " [%s]", objectBytes.length); return new LegacyObjectMetadata(ByteBuffer.allocate(OBJECT_SIZE).put(objectBytes)); } protected LegacyObjectMetadata(final ByteBuffer objectBuffer); static LegacyObjectMetadata fromBytes(final byte[] objectBytes); static LegacyObjectMetadata fromMetadata(final String objectName, final long objectSize, final int containerSuffix, final byte numLegalHolds, final int retentionPeriod); @Override String getName(); @Override long getSize(); @Override int getContainerSuffix(); @Override int getNumberOfLegalHolds(); @Override int getRetention(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override int compareTo(final ObjectMetadata o); @Override byte[] toBytes(); @Override String toString(); static final int OBJECT_NAME_SIZE; static final int OBJECT_SIZE_SIZE; static final int OBJECT_SUFFIX_SIZE; static final int OBJECT_LEGAL_HOLDS_SIZE; static final int OBJECT_RETENTION_SIZE; static final int OBJECT_SIZE; static final byte MAJOR_VERSION; static final byte MINOR_VERSION; }### Answer: @Test(expected = NullPointerException.class) public void nullFromBytes() { LegacyObjectMetadata.fromBytes(null); } @Test(expected = IllegalArgumentException.class) public void bytesLessThanObjectLength() { LegacyObjectMetadata.fromBytes(new byte[LegacyObjectMetadata.OBJECT_SIZE - 1]); } @Test(expected = IllegalArgumentException.class) public void bytesGreaterThanObjectLength() { LegacyObjectMetadata.fromBytes(new byte[LegacyObjectMetadata.OBJECT_SIZE + 1]); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.