# daikon-config.txt
# Copyright 2005 Christoph Csallner and Yannis Smaragdakis.

# Extended from Tao Xie's version:
# http://www.cs.washington.edu/homes/taoxie/jov/daikon_config.txt
# Eclat uses a list very similar to Tao's in:
# daikon.tools.runtimechecker.Property.calculateConfidence()

daikon.Daikon.progress_delay=10000

# Ignore the following crash of Daikon:
# Error: utilMDE.FileIOException:
# Duplicate declaration of program point
# "test.test(groovy.lang.ScriptContext):::ENTER"
# on line 19220281 of file JUnitAll.dtrace
# 
# Daikon 4.1.4 does not continue if DECLARE is duplicate:
# daikon/FileIO (line 782)
daikon.FileIO.continue_after_file_exception=true

# Enable splitting (default, disabled in Eclat)



# ###############################################
# Exclude some unary scalar invariants

# x one of {c1, c2, c3}
daikon.inv.unary.scalar.OneOfScalar.enabled=false
daikon.inv.unary.scalar.OneOfFloat.enabled=false
daikon.inv.unary.string.OneOfString.enabled=false



# ###############################################
# The remaining invariants in this file are expressed
# via /@ daikon.Quant.method(..) @/
# But no JML spec is available for these method calls.
# So ESC/Java2 has no benefit of these annotations.



# ###############################################
# Exclude all unary sequence invariants

# {e1, e2, e3, ...} subset of x[]
daikon.inv.unary.sequence.CommonSequence.enabled=false
daikon.inv.unary.sequence.CommonFloatSequence.enabled=false

# x[] elements {>=c,!=0,<=c}
daikon.inv.unary.sequence.EltLowerBound.enabled=false
daikon.inv.unary.sequence.EltNonZero.enabled=false
daikon.inv.unary.sequence.EltUpperBound.enabled=false
daikon.inv.unary.sequence.EltLowerBoundFloat.enabled=false
daikon.inv.unary.sequence.EltNonZeroFloat.enabled=false
daikon.inv.unary.sequence.EltUpperBoundFloat.enabled=false

# x[] one of {c1, c2, c3}
daikon.inv.unary.sequence.EltOneOf.enabled=false
daikon.inv.unary.sequence.EltOneOfFloat.enabled=false

# x[] sorted by {==,>=,>,<=,<}
daikon.inv.unary.sequence.EltwiseIntEqual.enabled=false
daikon.inv.unary.sequence.EltwiseIntGreaterEqual.enabled=false
daikon.inv.unary.sequence.EltwiseIntGreaterThan.enabled=false
daikon.inv.unary.sequence.EltwiseIntLessEqual.enabled=false
daikon.inv.unary.sequence.EltwiseIntLessThan.enabled=false
daikon.inv.unary.sequence.EltwiseFloatEqual.enabled=false
daikon.inv.unary.sequence.EltwiseFloatGreaterEqual.enabled=false
daikon.inv.unary.sequence.EltwiseFloatGreaterThan.enabled=false
daikon.inv.unary.sequence.EltwiseFloatLessEqual.enabled=false
daikon.inv.unary.sequence.EltwiseFloatLessThan.enabled=false

# x[] contains no duplicates
daikon.inv.unary.sequence.NoDuplicates.enabled=false
daikon.inv.unary.sequence.NoDuplicatesFloat.enabled=false

# x one of {c1, c2, c3}
daikon.inv.unary.sequence.OneOfSequence.enabled=false
daikon.inv.unary.sequence.OneOfFloatSequence.enabled=false

# x[i] {==,>=,>,<=,<,!=} i
daikon.inv.unary.sequence.SeqIndexIntEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexIntGreaterEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexIntGreaterThan.enabled=false
daikon.inv.unary.sequence.SeqIndexIntLessEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexIntLessThan.enabled=false
daikon.inv.unary.sequence.SeqIndexIntNonEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatGreaterEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatGreaterThan.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatLessEqual.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatLessThan.enabled=false
daikon.inv.unary.sequence.SeqIndexFloatNonEqual.enabled=false



# ###############################################
# Exclude all unary string sequence invariants

# x one of {c1, c2, c3}
daikon.inv.unary.stringsequence.OneOfStringSequence.enabled=false

# {s1, s2, s3, ...} subset of x[]
daikon.inv.unary.stringsequence.CommonStringSequence.enabled=false

# x[] one of {c1, c2, c3}
daikon.inv.unary.stringsequence.EltOneOfString.enabled=false



# ###############################################
# Exclude all binary scalar sequence invariants

# x in y[]
daikon.inv.binary.sequenceScalar.Member.enabled=false
daikon.inv.binary.sequenceScalar.MemberFloat.enabled=false

# x[] elements {==,>=,>,<=,<} y
daikon.inv.binary.sequenceScalar.SeqIntEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqIntGreaterEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqIntGreaterThan.enabled=false
daikon.inv.binary.sequenceScalar.SeqIntLessEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqIntLessThan.enabled=false
daikon.inv.binary.sequenceScalar.SeqFloatEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqFloatGreaterEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqFloatGreaterThan.enabled=false
daikon.inv.binary.sequenceScalar.SeqFloatLessEqual.enabled=false
daikon.inv.binary.sequenceScalar.SeqFloatLessThan.enabled=false



# ###############################################
# Exclude all binary string sequence invariants

# x in y[]
daikon.inv.binary.sequenceString.MemberString.enabled=false



# ###############################################
# Exclude some two scalar invariants

# x {==,>=,>,<=,<=,!=} y
daikon.inv.binary.twoScalar.FloatEqual.enabled=false
daikon.inv.binary.twoScalar.FloatGreaterEqual.enabled=false
daikon.inv.binary.twoScalar.FloatGreaterThan.enabled=false
daikon.inv.binary.twoScalar.FloatLessEqual.enabled=false
daikon.inv.binary.twoScalar.FloatLessThan.enabled=false
daikon.inv.binary.twoScalar.FloatNonEqual.enabled=false

# Include Numeric invariants excluded by Eclat and Tao



# ###############################################
# Exclude all two sequence invariants

# foreach i: x[i] {==,>=,>,<=,<} y[i]
daikon.inv.binary.twoSequence.PairwiseIntEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseIntGreaterEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseIntGreaterThan.enabled=false
daikon.inv.binary.twoSequence.PairwiseIntLessEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseIntLessThan.enabled=false
daikon.inv.binary.twoSequence.PairwiseFloatEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseFloatGreaterEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseFloatGreaterThan.enabled=false
daikon.inv.binary.twoSequence.PairwiseFloatLessEqual.enabled=false
daikon.inv.binary.twoSequence.PairwiseFloatLessThan.enabled=false

# foreach i: y[i] = ax[i] + b
daikon.inv.binary.twoSequence.PairwiseLinearBinary.enabled=false
daikon.inv.binary.twoSequence.PairwiseLinearBinaryFloat.enabled=false

# foreach i: x[i] {numericRelation} y[i]
daikon.inv.binary.twoSequence.PairwiseNumericFloat.enabled=false
daikon.inv.binary.twoSequence.PairwiseNumericInt.enabled=false

# x[] is the reverse of y[]
daikon.inv.binary.twoSequence.Reverse.enabled=false
daikon.inv.binary.twoSequence.ReverseFloat.enabled=false

# foreach i: x[i] {==,>=,>,<=,<} y[i]
daikon.inv.binary.twoSequence.SeqSeqIntEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqIntGreaterEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqIntGreaterThan.enabled=false
daikon.inv.binary.twoSequence.SeqSeqIntLessEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqIntLessThan.enabled=false
daikon.inv.binary.twoSequence.SeqSeqFloatEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqFloatGreaterEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqFloatGreaterThan.enabled=false
daikon.inv.binary.twoSequence.SeqSeqFloatLessEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqFloatLessThan.enabled=false
daikon.inv.binary.twoSequence.SeqSeqStringEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqStringGreaterEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqStringGreaterThan.enabled=false
daikon.inv.binary.twoSequence.SeqSeqStringLessEqual.enabled=false
daikon.inv.binary.twoSequence.SeqSeqStringLessThan.enabled=false
# TODO: Seems redundant to PairwiseIntEqual invariants

# x[] is a subsequence of y[]
daikon.inv.binary.twoSequence.SubSequence.enabled=false
daikon.inv.binary.twoSequence.SubSequenceFloat.enabled=false
daikon.inv.binary.twoSequence.SuperSequence.enabled=false
daikon.inv.binary.twoSequence.SuperSequenceFloat.enabled=false

# x[] is a subset of y[]
daikon.inv.binary.twoSequence.SubSet.enabled=false
daikon.inv.binary.twoSequence.SubSetFloat.enabled=false
daikon.inv.binary.twoSequence.SuperSet.enabled=false
daikon.inv.binary.twoSequence.SuperSetFloat.enabled=false



# ###############################################
# Keep all binary String invariants



# ###############################################
# Keep all tenary scalar invariants (excluded by Eclat and Tao)
