Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  import java.util.BitSet;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public class SPP_Sample implements Serializable {
     public static final long serialVersionUID = -2766574418713802220L;
 
     private static final double pi = 3.14;
     private static final double e = 2.72;
     public static final String FALSE_POSITIVE = "INTERN_OK_HERE".intern();
     private static final String LIT = "lit";
 
     static enum Flap {
         Smack, Jack
     };
 
     public void testSPPBitSet(BitSet b) {
         b.set(-1);
     }
 
     public String testSPPIntern() {
         return "FOO".intern(); // and yes i've seen this!
     }
 
     public String testSBWithChars() {
         StringBuffer sb = new StringBuffer('v');
         sb.append("ictory");
         return sb.toString();
     }
 
     public double area(double radius) {
         return  * radius * radius;
     }
 
     public void testStutter(String s) {
         String a = a = s;
     }
 
     public void testNAN(double d) {
         if (d == .) {
             ..println("It's a nan");
         }
     }
     
     public void testNAN2(Double d) {
         if (d == .) {
             ..println("It's a nan");
         }
         
         if (d.isNaN()) {
             ..println("It's properly a nan");
         }
     }
     
     public void testNotNAN(double d) {
         if (d != .) {
             ..println("It's not a nan");
         }
         
         if (!Double.isNaN(d)) {
             ..println("It's properly not a nan");
         }
     }
 
     public void testNAN(float f) {
         if (f == .) {
             ..println("It's a nan");
         }
     }
 
     public void testBigDecimal() {
         BigDecimal d = new BigDecimal(2.1);
         ..println(d);
     }
 
     public void testEmptySB() {
         StringBuffer sb = new StringBuffer("");
     }
 
     public void equalsOnEnum(Flap f) {
         if (f.equals(.)) {
             ..println("Flap Jacks");
         }
     }
 
    public void testCPPBoolean(Boolean aBoolean bBoolean cBoolean dBoolean e) {
        if (b && b.booleanValue()) {
            ..println("Booya");
        }
        if (e && e.booleanValue()) {
            ..println("Booya");
        }
    }
    public char usechatAt(String s) {
        if (s.length() > 0) {
            return s.toCharArray()[0];
        }
        return ' ';
    }
    public boolean testUselessTrinary(boolean b) {
        return (b ? true : false);
    }
    public void testDoubleAppendLiteral(StringBuilder sbString s) {
        sb.append("hello").append("there");     
        sb.append("Hello").append(s).append("there");
    }
    
    public String testFormatLiteral() {
    	return String.format("This string is not parameterized");
    }
        StringBuilder sb = new StringBuilder();
        sb.append("literal").append().append("literal");
        return sb.toString();
    }
    public boolean testFPUselessTrinary(boolean aboolean b) {
        if (a && b) {
            return a || b;
        }
        return a && b;
    }
    public boolean testFPTrinaryOnInt(String s) {
        return (s.length() != 0);
    }
    public void testSuspiciousStringTests(String s) {
        int a = 0, b = 0, c = 0, d = 0;
        String e = "Foo";
        if ((s == null) || (s.length() > 0)) {
            ..println("Booya");
        }
        if ((s == null) || (s.length() != 0)) {
            ..println("Booya");
        }
        if ((s != null) && (s.length() == 0)) {
            ..println("Booya");
        }
        if ((e == null) || (e.length() > 0)) {
            ..println("Booya");
        }
        if ((e == null) || (e.length() != 0)) {
            ..println("Booya");
        }
        if ((e != null) && (e.length() == 0)) {
            ..println("Booya");
        }
    }
    public void testFPSST(String s) {
        int a = 0, b = 0, c = 0, d = 0;
        String e = "Foo";
        if ((s == null) || (s.length() == 0)) {
            ..println("Booya");
        }
        if ((s != null) && (s.length() >= 0)) {
            ..println("Booya");
        }
        if ((s != null) && (s.length() != 0)) {
            ..println("Booya");
        }
        if ((e == null) || (e.length() == 0)) {
            ..println("Booya");
        }
        if ((e != null) && (e.length() >= 0)) {
            ..println("Booya");
        }
        if ((e != null) && (e.length() != 0)) {
            ..println("Booya");
        }
        Set<Stringm = new HashSet<String>();
        Iterator<Stringit = m.iterator();
        while (it.hasNext()) {
            s = it.next();
            if ((s == null) || (s.length() == 0)) {
                continue;
            }
            ..println("Booya");
        }
    }
    public void sbToString(StringBuffer sb) {
        if (sb.toString().length() == 0) {
            ..println("Booya");
        } else if (sb.toString().equals("")) {
            ..println("Booya");
        }
    }
    public String cpNullOrZero(StringTokenizer tokenizer) {
        while (tokenizer.hasMoreTokens()) {
            String sField = tokenizer.nextToken();
            if ((sField == null) || (sField.length() == 0)) {
                continue;
            }
            return sField;
        }
        return null;
    }
    public boolean testCalBeforeAfter(Calendar cDate d) {
        return c.after(d) || c.before(d);
    }
    public void testUseContainsKey(Map m) {
        if (m.keySet().contains("Foo")) {
            ..println("Yup");
        }
    }
    public void testCollectionSizeEqualsZero(Set<Strings) {
        if (s.size() == 0) {
            ..println("empty");
        }
        if (s.size() <= 0) {
            ..println("empty");
        }
    }
    public boolean testDerivedGregorianCalendar() {
        Calendar c = new GregorianCalendar() {
        };
        Calendar s = new GregorianCalendar();
        return s.after(c);
    }
    public void testGetProperties() {
        String lf = System.getProperties().getProperty("line.separator");
    }
    public boolean testCasing(String aString b) {
        if (a.toUpperCase().equalsIgnoreCase(b)) {
            return true;
        }
        if (a.toLowerCase().compareToIgnoreCase(b) == 0) {
            return true;
        }
        return false;
    }
    public void castRandomToInt() {
        int i = (int) Math.random();
        Random r = new Random();
        i = (intr.nextDouble();
        i = (intr.nextFloat();
    }
    public void testSAC(List<Stringinput) {
        String[] copy = new String[input.size()];
        System.arraycopy(input, 0, copy, 0, copy.length);
        System.arraycopy(copy, 0, input, 0, copy.length);
    }
    public void testArray() {
        List<StringnotAnArray = new ArrayList<String>();
        Array.getLength(notAnArray);
        Array.getBoolean(notAnArray, 0);
        Array.setInt(notAnArray, 0, 1);
    }
    public boolean testEmptyIgnoreCase(String s) {
        return (s.equalsIgnoreCase(""));
    }
    public void testTrim(String s) {
        if (s.trim().length() > 0)
            ..println(s);
        if (s.trim().equals("Booyah")) {
            ..println("Booyah->" + s);
        }
    }
    public void testSBAssigning(StringBuilder sb) {
        sb = sb.append("foo");
        sb = sb.append("foo").append("boo").append("hoo");
    }
    public String testListFirst(List<Stringl) {
        return l.iterator().next();
    }
    public boolean nullAndInstanceOf(Object o) {
        if ((o != null) && (o instanceof String)) {
            return true;
        }
        return false;
    }
    public boolean nullAndInstanceOf(double d1double d2double d3Object o) {
        if ((o != null) && (o instanceof String) && d1 < d2) {
            return true;
        }
        return false;
    }
    
    public String testStringToString(String x) {
    	//tag SPP_TOSTRING_ON_STRING (fb-contrib) and DM_STRING_TOSTRING (FindBugs)
        ..println(x.toString());
        
        //tag DM_CONVERT_CASE (FindBugs) and SPP_CONVERSION_OF_STRING_LITERAL
        ..println("SomeUpperCase".toLowerCase());
        //tag SPP_CONVERSION_OF_STRING_LITERAL
        ..println("SomeUpperCase".toLowerCase(.));
        //tag SPP_CONVERSION_OF_STRING_LITERAL
        ..println("SomeUpperCase".toUpperCase());
        //tag SPP_CONVERSION_OF_STRING_LITERAL
        ..println("SomeUpperCase".toUpperCase(.));
        //tag SPP_CONVERSION_OF_STRING_LITERAL
        ..println("  SomeUpperCase ".trim());
        
        //no tag
        ..println(x.toLowerCase());
        //no tag
        ..println(x.toLowerCase(.));
        //no tag
        ..println(x.toUpperCase());
        //no tag
        //no tag
        ..println(x.trim());
        return x;
    }
    public boolean fpNullAndInstanceOf(Object o) {
        if (o != null) {
            if (o instanceof String) {
                return true;
            }
            return false;
        }
        return Math.random() > 0.5;
    }
    public void testToString() {
        SPP_Sample s = new SPP_Sample();
        ..println(s.toString());
        /* only report it once */
        ..println(s.toString());
        
    }
    public void testFPToString(Object o) {
        ..println(o);
    }
    
New to GrepCode? Check out our FAQ X