private Map<Integer, Set<Integer>> getKillMap( List<Assertion> assertions, Map<Mutation, ExecutionResult> mutationResults) { Map<Integer, Set<Integer>> killMap = new HashMap<Integer, Set<Integer>>(); int num = 0; for (Assertion assertion : assertions) { Set<Integer> killedMutations = new HashSet<Integer>(); for (Mutation m : mutationResults.keySet()) { boolean isKilled = false; for (OutputTrace<?> trace : mutationResults.get(m).getTraces()) { if (trace.isDetectedBy(assertion)) { isKilled = true; break; } } if (isKilled) { killedMutations.add(m.getId()); assertion.addKilledMutation(m); } } killMap.put(num, killedMutations); num++; } return killMap; }
public void haveAttr(String attrName) { try { selenWebElement.getAttribute(attrName); Assertion.test(expect, true, "Test for Attribute availability"); } catch (Exception e) { Assertion.test(expect, false, "Test for Attribute availability"); } }
public void readonly() { String x = selenWebElement.getAttribute("readonly"); if (x == null) { Assertion.test(expect, false, "readonly"); } else if (x.equals("true")) { Assertion.test(expect, true, "readonly"); } }
public void focused() { WebElement elm = (WebElement) driver.executeScript("return document.activeElement"); if (elm != null && elm.equals(selenWebElement.getWebElement())) { Assertion.test(expect, true, "Test for elment foucsed"); } else { Assertion.test(expect, false, "Test for elment foucsed"); } }
public void disabled() { String x = selenWebElement.getAttribute("disabled"); if (x == null) { Assertion.test(expect, false, "disabled"); } else if (x.equals("true")) { Assertion.test(expect, true, "disabled"); } }
public void haveAttrVal(String attrName, String attrValue, boolean caseSensitive) { String attibValue = selenWebElement.getAttribute(attrName); if (!caseSensitive) { Assertion.test( expect, attrValue.toLowerCase(), attibValue.toLowerCase(), "Have Attribute value"); } else { Assertion.test(expect, attrValue, attibValue, "Have Attribute value"); } }
public void haveText(String regex, boolean caseSensitive) { String txt = selenWebElement.getText(); if (!caseSensitive) { regex = regex.toLowerCase(); txt = txt.toLowerCase(); } boolean res = Assertion.test(expect, txt.matches(regex), "Test for Text matching"); if (!res) { Assertion.printDetails(expect, regex, txt); } }
@SuppressWarnings("unchecked") private static <T extends Comparable<T>> void expectFail(Assertion assertion, T... args) throws Exception { try { Assertion.run(assertion, args); } catch (RuntimeException e) { return; } throw new Exception( "Expected " + Assertion.format(assertion, (Object[]) args) + " to throw a RuntimeException"); }
public void testSpecial() { LinkedList<Assertion> asserts = new LinkedList(); asserts.add(Assertion.create("John lives around here.")); asserts.add(Assertion.create("Mary lives around here.")); asserts.add(Assertion.create("The plumber lives in the yellow house.")); PuzzleSolver testS = new PuzzleSolver(asserts); LinkedList<String> names = testS.getNames(); LinkedList<String> occupations = testS.getOccupations(); LinkedList<String> colors = testS.getColors(); assertEquals("[John, Mary]", names.toString()); assertEquals("[plumber, #u]", occupations.toString()); assertEquals("[yellow, #u]", colors.toString()); }
private void directory_to_directory( String source_base_name, String destination_base_name, String directory_name) throws IOException, InterruptedException { // E.g. // source_base_name: /foo/bar // destination_base_name: /x/y // directory_name: abc // // - Create /x/y/abc // - Copy /foo/bar/abc/* to /x/y/abc/* // Get source directory. String source_directory_name = Path.concatenate(source_base_name, directory_name); File source_directory = File.create(source_directory_name); Assertion.check(source_directory.isDirectory()); // Get destination directory, creating it if // necessary. String destination_directory_name = Path.concatenate(destination_base_name, directory_name); File destination_directory = File.create(destination_directory_name); destination_directory.mkdirs(); // Get files in source directory String[] source_file_names = source_directory.list(); Vector source_files = new Vector(); for (int i = 0; i < source_file_names.length; i++) source_files.addElement(File.create(source_directory_name, source_file_names[i])); // Copy to_directory(source_files, destination_directory); }
public boolean imp() { boolean res = false; DbVariable dbVariable = null; String fullFileName = ""; String errMessage = null; DbImportFile dbInFile = new DbImportFile(); try { dbVariable = new DbVariable(); // Store the file on server filesystem fullFileName = dbInFile.storeImportFileBLOB(conn_viss, ifid); FileParser fileParser = new FileParser(fullFileName); fileParser.Parse( FileTypeDefinitionList.matchingDefinitions( FileTypeDefinition.VARIABLE, FileTypeDefinition.LIST)); dbVariable.CreateVariables(fileParser, connection, sampleUnitId, Integer.parseInt(userId)); errMessage = dbVariable.getErrorMessage(); Assertion.assertMsg(errMessage == null || errMessage.trim().equals(""), errMessage); dbInFile.setStatus(conn_viss, ifid, "IMPORTED"); // dbInFile.UpdateImportFile(connection,null,null,"Done",Integer.parseInt(ifid),Integer.parseInt(userId)); // Add a message to the log dbInFile.addErrMsg( conn_viss, ifid, "File imported to sampling unit " + DbSamplingUnit.getSUName(conn_viss, Integer.toString(sampleUnitId)) + "Note: Markers is always imported in Create mode."); res = true; } catch (Exception e) { Errors.logError("ImportVariables.imp(...)" + e.getMessage()); dbInFile.setStatus(conn_viss, ifid, "ERROR"); // dbInFile.UpdateImportFile(connection,null,null,e.getMessage(),Integer.parseInt(ifid),Integer.parseInt(userId)); // Add a message to the log dbInFile.addErrMsg(conn_viss, ifid, e.getMessage()); e.printStackTrace(System.err); if (errMessage == null) { errMessage = e.getMessage(); } } finally { try { /* * Delete files uploaded */ File tmp = new File(fullFileName); tmp.delete(); } catch (Exception ignore) { } } return res; }
/** * Get all possible assertions * * @param test a {@link org.evosuite.testcase.TestCase} object. * @return a int. */ public int getAllAssertions(TestCase test, int statement) { int num = 0; if (!trace.containsKey(statement)) return 0; for (Integer var : trace.get(statement).keySet()) { for (Assertion assertion : trace.get(statement).get(var).getAssertions()) { assert (assertion.isValid()) : "Invalid assertion: " + assertion.getCode() + ", " + assertion.value; test.getStatement(statement).addAssertion(assertion); num++; } } return num; }
/** * For the specified expected and actual tables (and excluding and including the specified * columns), verify the actual data is as expected. * * @param expectedTable The expected table to compare the actual table to. * @param actualTable The actual table to compare to the expected table. * @param excludeColumns The column names to exclude from comparison. See {@link * org.dbunit.dataset.filter.DefaultColumnFilter#excludeColumn(String)} . * @param includeColumns The column names to only include in comparison. See {@link * org.dbunit.dataset.filter.DefaultColumnFilter#includeColumn(String)} . * @throws DatabaseUnitException */ public void verifyData( ITable expectedTable, ITable actualTable, String[] excludeColumns, String[] includeColumns) throws DatabaseUnitException { final String method = "verifyData: "; // Filter out the columns from the expected and actual results LOG.debug(method + "Applying filters to expected table"); ITable expectedFilteredTable = applyColumnFilters(expectedTable, excludeColumns, includeColumns); LOG.debug(method + "Applying filters to actual table"); ITable actualFilteredTable = applyColumnFilters(actualTable, excludeColumns, includeColumns); LOG.debug(method + "Sorting expected table"); SortedTable expectedSortedTable = new SortedTable(expectedFilteredTable); LOG.debug(method + "Sorted expected table={}", expectedSortedTable); LOG.debug(method + "Sorting actual table"); SortedTable actualSortedTable = new SortedTable(actualFilteredTable, expectedFilteredTable.getTableMetaData()); LOG.debug(method + "Sorted actual table={}", actualSortedTable); LOG.debug(method + "Comparing expected table to actual table"); Column[] additionalColumnInfo = expectedTable.getTableMetaData().getColumns(); Assertion.assertEquals(expectedSortedTable, actualSortedTable, additionalColumnInfo); }
public void haveStyle(String styleProperty, String styleValue) { String val = selenWebElement.getCssValue(styleProperty); Assertion.test( expect, styleValue.toLowerCase(), val.toLowerCase(), "Test for css Style property matching"); }
/** * Returns the definition of the selected attribute / object class OID. * * @param schemaEntry The selected schema entry to search on. * @param type The type of the research. ("objectClasses" or "attributeTypes") * @param oid The OID of the element to search for. * @return The byte string definition of the element. */ private static ByteString getSchemaElement( final Entry schemaEntry, final String type, final String oid) { final Attribute attribute = schemaEntry.getAttribute(type); final MatchingRule mrule = CoreSchema.getObjectIdentifierFirstComponentMatchingRule(); Assertion assertion; try { assertion = mrule.getAssertion(ByteString.valueOfUtf8(oid)); for (final ByteString value : attribute) { final ByteString nvalue = mrule.normalizeAttributeValue(value); if (assertion.matches(nvalue).toBoolean()) { return value; } } } catch (DecodeException e) { throw new IllegalStateException(e); } throw new IllegalStateException(ERR_UPGRADE_UNKNOWN_OC_ATT.get(type, oid).toString()); }
/** * Get all possible assertions * * @param test a {@link org.evosuite.testcase.TestCase} object. * @return a int. */ public int getAllAssertions(TestCase test) { int num = 0; for (Integer statement : trace.keySet()) { for (Integer var : trace.get(statement).keySet()) { for (Assertion assertion : trace.get(statement).get(var).getAssertions()) { assert (assertion.isValid()) : "Invalid assertion: " + assertion.getCode() + ", " + assertion.value; if (test.sizeWithAssertions() >= Properties.MAX_LENGTH_TEST_CASE) { return num; } test.getStatement(statement).addAssertion(assertion); num++; } } } return num; }
@Override public void close() throws SQLException { Statement stmt = conn.createStatement(); try { stmt.execute("PRAGMA journal_mode=DELETE"); { ResultSet rs = stmt.executeQuery("PRAGMA journal_mode"); Assertion.assertAssertionError(rs.next()); Assertion.assertAssertionError( rs.getString("journal_mode").equals("delete"), "journal_mode=" + rs.getString("journal_mode")); rs.close(); } } finally { stmt.close(); } super.close(); }
@Test public void testBeamFactoryGaussian() { BeamFactory bf = new BeamFactory(); Beam b = bf.createBeam("gaussian", defaultProperties()); assertTrue(b instanceof BeamGaussian); Assertion.equals(b.getPhotonEnergy(), BEAMENERGYMARKER, "Beam Energy"); System.out.println("@Test - testBeamFactoryGaussian"); }
/** * Check if this trace makes the assertion fail * * @param assertion a {@link org.evosuite.assertion.Assertion} object. * @return a boolean. */ public boolean isDetectedBy(Assertion assertion) { assert (assertion.isValid()); for (Integer statement : trace.keySet()) { for (Integer var : trace.get(statement).keySet()) { if (trace.get(statement).get(var).isDetectedBy(assertion)) return true; } } return false; }
/** * Get all assertions based on trace differences * * @param test a {@link org.evosuite.testcase.TestCase} object. * @param other a {@link org.evosuite.assertion.OutputTrace} object. * @return a int. */ public int getAssertions(TestCase test, OutputTrace<?> other) { int num = 0; for (Integer statement : trace.keySet()) { if (other.trace.containsKey(statement)) { logger.debug("Other trace contains " + statement); for (Integer var : trace.get(statement).keySet()) { logger.debug("Variable " + var); for (Assertion assertion : trace.get(statement).get(var).getAssertions(other.trace.get(statement).get(var))) { assert (assertion.isValid()) : "Invalid assertion: " + assertion.getCode() + ", " + assertion.value; test.getStatement(statement).addAssertion(assertion); num++; } } } } return num; }
@Test public void checkElementDB() { ElementDatabase edb = ElementDatabase.getInstance(); Element s = edb.getElement("S"); Assertion.isNotNull(s, "Could not find sulphur by name"); Element s16 = edb.getElement(16); Assertion.isNotNull(s16, "Could not find sulphur by element number"); assertSame(s, s16); ElementTest et = new ElementTest(); et.sulphurTests(s); Element o = edb.getElement("o"); Assertion.isNotNull(o, "Could not find oxygen by name"); Element o8 = edb.getElement(8); Assertion.isNotNull(o8, "Could not find oxygen by element number"); assertSame(o, o8); for (int i = 1; i <= 83; i++) { Element e = edb.getElement(i); Assertion.isNotNull(e, "Could not find element no. " + i); } Element mg = edb.getElement("Mg"); Assertion.isNotNull(mg, "Could not find manganese by name"); et.manganeseTests(mg); }
public void testAssociation() { LinkedList<Assertion> asserts = new LinkedList(); asserts.add(Assertion.create("John lives around here.")); asserts.add(Assertion.create("Mary lives around here.")); asserts.add(Assertion.create("Simon lives around here.")); asserts.add(Assertion.create("Mary lives in the blue house.")); asserts.add(Assertion.create("The plumber lives in the yellow house.")); asserts.add(Assertion.create("The carpenter lives around here.")); PuzzleSolver testS = new PuzzleSolver(asserts); PermutationPairs testP = new PermutationPairs(3); String[][] possibility = testS.associatePermsWithStrings(testP.nextPair()); assertEquals("John", possibility[0][0]); assertEquals("plumber", possibility[0][1]); assertEquals("blue", possibility[0][2]); assertEquals("Mary", possibility[1][0]); assertEquals("carpenter", possibility[1][1]); assertEquals("yellow", possibility[1][2]); assertEquals("Simon", possibility[2][0]); assertEquals("#u", possibility[2][1]); assertEquals("#u", possibility[2][2]); }
public void testOne() { LinkedList<Assertion> asserts = new LinkedList(); asserts.add(Assertion.create("John lives around here.")); PuzzleSolver testS = new PuzzleSolver(asserts); LinkedList<String> names = testS.getNames(); LinkedList<String> occupations = testS.getOccupations(); LinkedList<String> colors = testS.getColors(); assertEquals("[John]", names.toString()); assertEquals("[#u]", occupations.toString()); assertEquals("[#u]", colors.toString()); }
private Map<String, Object> getUserAttributes(ResponseImpl samlResponse) { Map<String, Object> userAttributes = new HashMap<>(); // Add 'Subject' Assertion assertion = samlResponse.getAssertions().get(0); userAttributes.put( SAMLConstants.SAML2_ASSERTION_SUBJECT, assertion.getSubject().getNameID().getValue()); // Add other user attributes. List<AttributeStatement> attributeStatements = assertion.getAttributeStatements(); if (attributeStatements != null) { for (AttributeStatement attributeStatement : attributeStatements) { List<Attribute> attributes = attributeStatement.getAttributes(); for (Attribute attribute : attributes) { userAttributes.put( attribute.getName(), attribute.getAttributeValues().get(0).getDOM().getTextContent()); } } } return userAttributes; }
private void to_directory(Vector sources, File destination_directory) throws IOException, InterruptedException { Assertion.check(destination_directory.exists()); for (Enumeration source_scan = sources.elements(); source_scan.hasMoreElements(); ) { File source = (File) source_scan.nextElement(); if (source.isFile()) { File destination = File.create(destination_directory.getPath(), source.getName()); file_to_file(source, destination); } else if (_recursive) { String source_base = source.getParent(); if (source_base == null) source_base = "."; String destination_base = destination_directory.getCanonicalPath(); directory_to_directory(source_base, destination_base, source.getName()); } } }
@Override protected boolean isSatisfiedByInternal(final Assertion assertion) { return (assertion.getChainedAuthentications().size() == 1); }
public void doAssert(Assertion assertion) throws TimeoutException { withCondition(assertion.getCondition()).poll(); }
private Assertion buildSAMLAssertion( SAMLSSOAuthnReqDTO authReqDTO, DateTime notOnOrAfter, String sessionId) throws IdentityException { try { DateTime currentTime = new DateTime(); Assertion samlAssertion = new AssertionBuilder().buildObject(); samlAssertion.setID(SAMLSSOUtil.createID()); samlAssertion.setVersion(SAMLVersion.VERSION_20); samlAssertion.setIssuer(SAMLSSOUtil.getIssuer()); samlAssertion.setIssueInstant(currentTime); Subject subject = new SubjectBuilder().buildObject(); NameID nameId = new NameIDBuilder().buildObject(); if (authReqDTO.getUseFullyQualifiedUsernameAsSubject()) { nameId.setValue(authReqDTO.getUsername()); nameId.setFormat(NameIdentifier.EMAIL); } else { nameId.setValue(MultitenantUtils.getTenantAwareUsername(authReqDTO.getUsername())); nameId.setFormat(authReqDTO.getNameIDFormat()); } subject.setNameID(nameId); SubjectConfirmation subjectConfirmation = new SubjectConfirmationBuilder().buildObject(); subjectConfirmation.setMethod(SAMLSSOConstants.SUBJECT_CONFIRM_BEARER); SubjectConfirmationData scData = new SubjectConfirmationDataBuilder().buildObject(); scData.setRecipient(authReqDTO.getAssertionConsumerURL()); scData.setNotOnOrAfter(notOnOrAfter); scData.setInResponseTo(authReqDTO.getId()); subjectConfirmation.setSubjectConfirmationData(scData); subject.getSubjectConfirmations().add(subjectConfirmation); samlAssertion.setSubject(subject); AuthnStatement authStmt = new AuthnStatementBuilder().buildObject(); authStmt.setAuthnInstant(new DateTime()); AuthnContext authContext = new AuthnContextBuilder().buildObject(); AuthnContextClassRef authCtxClassRef = new AuthnContextClassRefBuilder().buildObject(); authCtxClassRef.setAuthnContextClassRef(AuthnContext.PASSWORD_AUTHN_CTX); authContext.setAuthnContextClassRef(authCtxClassRef); authStmt.setAuthnContext(authContext); if (authReqDTO.isDoSingleLogout()) { authStmt.setSessionIndex(sessionId); } samlAssertion.getAuthnStatements().add(authStmt); /* * If <AttributeConsumingServiceIndex> element is in the * <AuthnRequest> and * according to the spec 2.0 the subject MUST be in the assertion */ Map<String, String> claims = SAMLSSOUtil.getAttributes(authReqDTO); if (claims != null) { samlAssertion.getAttributeStatements().add(buildAttributeStatement(claims)); } AudienceRestriction audienceRestriction = new AudienceRestrictionBuilder().buildObject(); Audience issuerAudience = new AudienceBuilder().buildObject(); issuerAudience.setAudienceURI(authReqDTO.getIssuer()); audienceRestriction.getAudiences().add(issuerAudience); if (authReqDTO.getRequestedAudiences() != null) { for (String requestedAudience : authReqDTO.getRequestedAudiences()) { Audience audience = new AudienceBuilder().buildObject(); audience.setAudienceURI(requestedAudience); audienceRestriction.getAudiences().add(audience); } } Conditions conditions = new ConditionsBuilder().buildObject(); conditions.setNotBefore(currentTime); conditions.setNotOnOrAfter(notOnOrAfter); conditions.getAudienceRestrictions().add(audienceRestriction); samlAssertion.setConditions(conditions); if (authReqDTO.getDoSignAssertions()) { SAMLSSOUtil.setSignature( samlAssertion, XMLSignature.ALGO_ID_SIGNATURE_RSA, new SignKeyDataHolder(authReqDTO.getUsername())); } return samlAssertion; } catch (Exception e) { log.error("Error when reading claim values for generating SAML Response", e); throw new IdentityException( "Error when reading claim values for generating SAML Response", e); } }
public boolean imp() { boolean res = false; String errMessage = null; DbImportFile dbInFile = new DbImportFile(); DbPhenotype dbp = new DbPhenotype(); String fullFileName = null; try { Errors.logInfo("CheckPhenotype started"); // connection.setAutoCommit(false); dbInFile.setStatus(conn_viss, ifid, "0%"); fullFileName = dbInFile.storeImportFileBLOB(conn_viss, ifid); FileHeader header = FileParser.scanFileHeader(fullFileName); FileParser fileParser = new FileParser(fullFileName); // Set status dbInFile.setStatus(conn_viss, ifid, "10%"); // Ensure file format is list or matrix Assertion.assertMsg( header.formatTypeName().equalsIgnoreCase(FileTypeDefinition.LIST) || header.formatTypeName().equalsIgnoreCase(FileTypeDefinition.MATRIX), "Format type name should be list or matrix " + "but found found " + header.formatTypeName()); // If file is a list if (header.formatTypeName().equalsIgnoreCase(FileTypeDefinition.LIST)) { fileParser.Parse( FileTypeDefinitionList.matchingDefinitions( FileTypeDefinition.PHENOTYPE, FileTypeDefinition.LIST)); dbInFile.setStatus(conn_viss, ifid, "20%"); if (updateMethod.equals("CREATE")) { dbp.CreatePhenotypesList( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } else if (updateMethod.equals("UPDATE")) { dbp.UpdatePhenotypesList( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } else if (updateMethod.equals("CREATE_OR_UPDATE")) { dbp.CreateOrUpdatePhenotypesList( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } } // If file is a matrix else if (header.formatTypeName().equalsIgnoreCase(FileTypeDefinition.MATRIX)) { fileParser.Parse( FileTypeDefinitionList.matchingDefinitions( FileTypeDefinition.PHENOTYPE, FileTypeDefinition.MATRIX)); dbInFile.setStatus(conn_viss, ifid, "20%"); if (updateMethod.equals("CREATE")) { dbp.CreatePhenotypesMatrix( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } else if (updateMethod.equals("UPDATE")) { dbp.UpdatePhenotypesMatrix( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } else if (updateMethod.equals("CREATE_OR_UPDATE")) { dbp.CreateOrUpdatePhenotypesMatrix( fileParser, connection, sampleUnitId, Integer.valueOf(userId).intValue()); } } errMessage = dbp.getErrorMessage(); Assertion.assertMsg(errMessage == null || errMessage.trim().equals(""), errMessage); dbInFile.setStatus(conn_viss, ifid, "IMPORTED"); // Add a message to the log dbInFile.addErrMsg( conn_viss, ifid, "File imported for sampling unit " + DbSamplingUnit.getSUName(conn_viss, Integer.toString(sampleUnitId))); res = true; Errors.logInfo("Check Phenotype ended"); } catch (Exception e) { // Flag for error and set the errMessage if it has not been set // isOk = false; dbInFile.setStatus(conn_viss, ifid, "ERROR"); // Add a message to the log dbInFile.addErrMsg(conn_viss, ifid, e.getMessage()); e.printStackTrace(System.err); if (errMessage == null) { errMessage = e.getMessage(); } } return res; }
SqliteDirTreeDb(String filename) throws SQLException, ClassNotFoundException { Class.forName("org.sqlite.JDBC"); File fileobj = new File(filename); boolean fileExists = fileobj.exists(); SQLiteConfig config = new SQLiteConfig(); config.setBusyTimeout(String.valueOf(60 * 1000)); conn = DriverManager.getConnection("jdbc:sqlite:" + filename, config.toProperties()); conn.setAutoCommit(true); Statement stmt = conn.createStatement(); try { stmt.execute("PRAGMA synchronous=OFF"); { ResultSet rs = stmt.executeQuery("PRAGMA synchronous"); Assertion.assertAssertionError(rs.next()); Assertion.assertAssertionError( rs.getInt("synchronous") == 0, "synchronous=" + rs.getInt("synchronous")); rs.close(); } stmt.execute("PRAGMA journal_mode=PERSIST"); { ResultSet rs = stmt.executeQuery("PRAGMA journal_mode"); Assertion.assertAssertionError(rs.next()); Assertion.assertAssertionError( rs.getString("journal_mode").equals("persist"), "journal_mode=" + rs.getString("journal_mode")); rs.close(); } if (!fileExists) { stmt.executeUpdate( "CREATE TABLE IF NOT EXISTS directory (pathid INTEGER PRIMARY KEY AUTOINCREMENT, " + "parentid INTEGER NOT NULL, rootid INTEGER, datelastmodified TEXT NOT NULL, " + "size INTEGER NOT NULL, compressedsize INTEGER NOT NULL, csum INTEGER, " + "path TEXT UNIQUE NOT NULL, type INTEGER NOT NULL, status INTEGER NOT NULL, " + "duplicate INTEGER NOT NULL, dedupablesize INTEGER NOT NULL, " + "CONSTRAINT pathid_size_csum UNIQUE (pathid, size, csum))"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_parentid ON directory (parentid)"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_rootid ON directory (rootid)"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS directory_datelastmodified ON directory (datelastmodified)"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_size ON directory (size)"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS directory_compressedsize ON directory (compressedsize)"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_csum ON directory (csum)"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS directory_size_csum ON directory (size, csum)"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_type ON directory (type)"); stmt.executeUpdate("CREATE INDEX IF NOT EXISTS directory_status ON directory (status)"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS directory_duplicate ON directory (duplicate)"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS directory_dedupablesize ON directory (dedupablesize)"); stmt.executeUpdate( "INSERT OR IGNORE INTO directory (path, parentid, datelastmodified, size, " + "compressedsize, type, status, duplicate, dedupablesize) " + "VALUES ('C:\\', 0, '2000-01-01 00:00:00', 0, 0, 0, 1, 0, 0)"); stmt.executeUpdate( "CREATE TABLE IF NOT EXISTS upperlower (upper INTEGER NOT NULL, " + "lower INTEGER NOT NULL, distance INTEGER NOT NULL, PRIMARY KEY (upper, lower))"); stmt.executeUpdate( "CREATE INDEX IF NOT EXISTS upperlower_distance ON upperlower (distance)"); stmt.executeUpdate( "CREATE TABLE IF NOT EXISTS equality (" + "pathid1 INTEGER NOT NULL, pathid2 INTEGER NOT NULL, " + "size INTEGER NOT NULL, csum INTEGER NOT NULL, " + "datelasttested TEXT NOT NULL, PRIMARY KEY (pathid1, pathid2))"); } stmt.executeUpdate( "UPDATE directory SET rootid=pathid WHERE rootid IS NULL AND pathid IS NOT NULL"); } finally { stmt.close(); } }