path: root/compiler/src/test/java/android/databinding/tool/expr/ExprModelTest.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.databinding.tool.expr;

import android.databinding.Bindable;
import android.databinding.Observable;
import android.databinding.tool.LayoutBinder;
import android.databinding.tool.MockLayoutBinder;
import android.databinding.tool.reflection.ModelAnalyzer;
import android.databinding.tool.reflection.ModelClass;
import android.databinding.tool.reflection.java.JavaAnalyzer;
import android.databinding.tool.store.Location;
import android.databinding.tool.util.L;
import android.databinding.tool.writer.KCode;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

@SuppressWarnings("Duplicates")
public class ExprModelTest {

    private static class DummyExpr extends Expr {

        String mKey;

        public DummyExpr(String key, DummyExpr... children) {
            super(children);
            mKey = key;
        }

        @Override
        protected ModelClass resolveType(ModelAnalyzer modelAnalyzer) {
            return modelAnalyzer.findClass(Integer.class);
        }

        @Override
        protected List<Dependency> constructDependencies() {
            return constructDynamicChildrenDependencies();
        }

        @Override
        protected String computeUniqueKey() {
            return mKey + super.computeUniqueKey();
        }

        @Override
        protected KCode generateCode() {
            return new KCode();
        }

        @Override
        public Expr cloneToModel(ExprModel model) {
            return this;
        }

        @Override
        protected String getInvertibleError() {
            return "DummyExpr cannot be 2-way.";
        }
    }

    ExprModel mExprModel;

    @Rule
    public TestWatcher mTestWatcher = new TestWatcher() {
        @Override
        protected void failed(Throwable e, Description description) {
            if (mExprModel != null && mExprModel.getFlagMapping() != null) {
                final String[] mapping = mExprModel.getFlagMapping();
                for (int i = 0; i < mapping.length; i++) {
                    L.d("flag %d: %s", i, mapping[i]);
                }
            }
        }
    };

    @Before
    public void setUp() throws Exception {
        JavaAnalyzer.initForTests();
        mExprModel = new ExprModel();
    }

    @Test
    public void testAddNormal() {
        final DummyExpr d = new DummyExpr("a");
        assertSame(d, mExprModel.register(d));
        assertSame(d, mExprModel.register(d));
        assertEquals(1, mExprModel.mExprMap.size());
    }

    @Test
    public void testAddDupe1() {
        final DummyExpr d = new DummyExpr("a");
        assertSame(d, mExprModel.register(d));
        assertSame(d, mExprModel.register(new DummyExpr("a")));
        assertEquals(1, mExprModel.mExprMap.size());
    }

    @Test
    public void testAddMultiple() {
        mExprModel.register(new DummyExpr("a"));
        mExprModel.register(new DummyExpr("b"));
        assertEquals(2, mExprModel.mExprMap.size());
    }


    @Test
    public void testAddWithChildren() {
        DummyExpr a = new DummyExpr("a");
        DummyExpr b = new DummyExpr("b");
        DummyExpr c = new DummyExpr("c", a, b);
        mExprModel.register(c);
        DummyExpr a2 = new DummyExpr("a");
        DummyExpr b2 = new DummyExpr("b");
        DummyExpr c2 = new DummyExpr("c", a, b);
        assertEquals(c, mExprModel.register(c2));
    }

    @Test
    public void testShouldRead() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", "java.lang.String", null);
        IdentifierExpr b = lb.addVariable("b", "java.lang.String", null);
        IdentifierExpr c = lb.addVariable("c", "java.lang.String", null);
        lb.parse("a == null ? b : c", null, null);
        mExprModel.comparison("==", a, mExprModel.symbol("null", Object.class));
        lb.getModel().seal();
        List<Expr> shouldRead = getShouldRead();
        // a and a == null
        assertEquals(2, shouldRead.size());
        final List<Expr> readFirst = getReadFirst(shouldRead, null);
        assertEquals(1, readFirst.size());
        final Expr first = readFirst.get(0);
        assertSame(a, first);
        // now , assume we've read this
        final BitSet shouldReadFlags = first.getShouldReadFlags();
        assertNotNull(shouldReadFlags);
    }

    @Test
    public void testReadConstantTernary() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", "java.lang.String", null);
        IdentifierExpr b = lb.addVariable("b", "java.lang.String", null);
        TernaryExpr ternaryExpr = parse(lb, "true ? a : b", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, ternaryExpr.getPred());
        List<Expr> first = getReadFirst(shouldRead);
        assertExactMatch(first, ternaryExpr.getPred());
        mExprModel.markBitsRead();
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b, ternaryExpr);
        first = getReadFirst(shouldRead);
        assertExactMatch(first, a, b);
        List<Expr> justRead = new ArrayList<Expr>();
        justRead.add(a);
        justRead.add(b);
        first = filterOut(getReadFirst(shouldRead, justRead), justRead);
        assertExactMatch(first, ternaryExpr);
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testTernaryWithPlus() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr user = lb
                .addVariable("user", "android.databinding.tool.expr.ExprModelTest.User",
                        null);
        MathExpr parsed = parse(lb, "user.name + \" \" + (user.lastName ?? \"\")", MathExpr.class);
        mExprModel.seal();
        List<Expr> toRead = getShouldRead();
        List<Expr> readNow = getReadFirst(toRead);
        assertEquals(1, readNow.size());
        assertSame(user, readNow.get(0));
        List<Expr> justRead = new ArrayList<Expr>();
        justRead.add(user);
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(2, readNow.size()); //user.name && user.lastName
        justRead.addAll(readNow);
        // user.lastname (T, F), user.name + " "
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(2, readNow.size()); //user.name && user.lastName
        justRead.addAll(readNow);
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(0, readNow.size());
        mExprModel.markBitsRead();

        toRead = getShouldRead();
        assertEquals(2, toRead.size());
        justRead.clear();
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(1, readNow.size());
        assertSame(parsed.getRight(), readNow.get(0));
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(1, readNow.size());
        assertSame(parsed, readNow.get(0));
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertEquals(0, readNow.size());
        mExprModel.markBitsRead();
        assertEquals(0, getShouldRead().size());
    }

    private List<Expr> filterOut(List<Expr> itr, final List<Expr> exclude) {
        List<Expr> result = new ArrayList<Expr>();
        for (Expr expr : itr) {
            if (!exclude.contains(expr)) {
                result.add(expr);
            }
        }
        return result;
    }

    @Test
    public void testTernaryInsideTernary() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr cond1 = lb.addVariable("cond1", "boolean", null);
        IdentifierExpr cond2 = lb.addVariable("cond2", "boolean", null);

        IdentifierExpr a = lb.addVariable("a", "boolean", null);
        IdentifierExpr b = lb.addVariable("b", "boolean", null);
        IdentifierExpr c = lb.addVariable("c", "boolean", null);

        final TernaryExpr ternaryExpr = parse(lb, "cond1 ? cond2 ? a : b : c", TernaryExpr.class);
        final TernaryExpr innerTernary = (TernaryExpr) ternaryExpr.getIfTrue();
        mExprModel.seal();

        List<Expr> toRead = getShouldRead();
        assertEquals(1, toRead.size());
        assertEquals(ternaryExpr.getPred(), toRead.get(0));

        List<Expr> readNow = getReadFirst(toRead);
        assertEquals(1, readNow.size());
        assertEquals(ternaryExpr.getPred(), readNow.get(0));
        int cond1True = ternaryExpr.getRequirementFlagIndex(true);
        int cond1False = ternaryExpr.getRequirementFlagIndex(false);
        // ok, it is read now.
        mExprModel.markBitsRead();

        // now it should read cond2 or c, depending on the flag from first
        toRead = getShouldRead();
        assertEquals(2, toRead.size());
        assertExactMatch(toRead, ternaryExpr.getIfFalse(), innerTernary.getPred());
        assertFlags(ternaryExpr.getIfFalse(), cond1False);
        assertFlags(ternaryExpr.getIfTrue(), cond1True);

        mExprModel.markBitsRead();

        // now it should read a or b, innerTernary, outerTernary
        toRead = getShouldRead();
        assertExactMatch(toRead, innerTernary.getIfTrue(), innerTernary.getIfFalse(), ternaryExpr,
                innerTernary);
        assertFlags(innerTernary.getIfTrue(), innerTernary.getRequirementFlagIndex(true));
        assertFlags(innerTernary.getIfFalse(), innerTernary.getRequirementFlagIndex(false));
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testRequirementFlags() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", "java.lang.String", null);
        IdentifierExpr b = lb.addVariable("b", "java.lang.String", null);
        IdentifierExpr c = lb.addVariable("c", "java.lang.String", null);
        IdentifierExpr d = lb.addVariable("d", "java.lang.String", null);
        IdentifierExpr e = lb.addVariable("e", "java.lang.String", null);
        final Expr aTernary = lb.parse("a == null ? b == null ? c : d : e", null, null);
        assertTrue(aTernary instanceof TernaryExpr);
        final Expr bTernary = ((TernaryExpr) aTernary).getIfTrue();
        assertTrue(bTernary instanceof TernaryExpr);
        final Expr aIsNull = mExprModel
                .comparison("==", a, mExprModel.symbol("null", Object.class));
        final Expr bIsNull = mExprModel
                .comparison("==", b, mExprModel.symbol("null", Object.class));
        lb.getModel().seal();
        List<Expr> shouldRead = getShouldRead();
        // a and a == null
        assertEquals(2, shouldRead.size());
        assertFalse(a.getShouldReadFlags().isEmpty());
        assertTrue(a.getShouldReadFlags().get(a.getId()));
        assertTrue(b.getShouldReadFlags().isEmpty());
        assertTrue(c.getShouldReadFlags().isEmpty());
        assertTrue(d.getShouldReadFlags().isEmpty());
        assertTrue(e.getShouldReadFlags().isEmpty());

        List<Expr> readFirst = getReadFirst(shouldRead, null);
        assertEquals(1, readFirst.size());
        final Expr first = readFirst.get(0);
        assertSame(a, first);
        assertTrue(mExprModel.markBitsRead());
        for (Expr expr : mExprModel.getPendingExpressions()) {
            assertNull(expr.mShouldReadFlags);
        }
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, e, b, bIsNull);

        assertFlags(e, aTernary.getRequirementFlagIndex(false));

        assertFlags(b, aTernary.getRequirementFlagIndex(true));
        assertFlags(bIsNull, aTernary.getRequirementFlagIndex(true));
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertEquals(4, shouldRead.size());
        assertTrue(shouldRead.contains(c));
        assertTrue(shouldRead.contains(d));
        assertTrue(shouldRead.contains(aTernary));
        assertTrue(shouldRead.contains(bTernary));

        assertTrue(c.getShouldReadFlags().get(bTernary.getRequirementFlagIndex(true)));
        assertEquals(1, c.getShouldReadFlags().cardinality());

        assertTrue(d.getShouldReadFlags().get(bTernary.getRequirementFlagIndex(false)));
        assertEquals(1, d.getShouldReadFlags().cardinality());

        assertTrue(bTernary.getShouldReadFlags().get(aTernary.getRequirementFlagIndex(true)));
        assertEquals(1, bTernary.getShouldReadFlags().cardinality());
        // +1 for invalidate all flag
        assertEquals(6, aTernary.getShouldReadFlags().cardinality());
        for (Expr expr : new Expr[]{a, b, c, d, e}) {
            assertTrue(aTernary.getShouldReadFlags().get(expr.getId()));
        }

        readFirst = getReadFirst(shouldRead);
        assertEquals(2, readFirst.size());
        assertTrue(readFirst.contains(c));
        assertTrue(readFirst.contains(d));
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testPostConditionalDependencies() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();

        IdentifierExpr u1 = lb.addVariable("u1", User.class.getCanonicalName(), null);
        IdentifierExpr u2 = lb.addVariable("u2", User.class.getCanonicalName(), null);
        IdentifierExpr a = lb.addVariable("a", int.class.getCanonicalName(), null);
        IdentifierExpr b = lb.addVariable("b", int.class.getCanonicalName(), null);
        IdentifierExpr c = lb.addVariable("c", int.class.getCanonicalName(), null);
        IdentifierExpr d = lb.addVariable("d", int.class.getCanonicalName(), null);
        IdentifierExpr e = lb.addVariable("e", int.class.getCanonicalName(), null);
        TernaryExpr abTernary = parse(lb, "a > b ? u1.name : u2.name", TernaryExpr.class);
        TernaryExpr bcTernary = parse(lb, "b > c ? u1.getCond(d) ? u1.lastName : u2.lastName : `xx`"
                + " + u2.getCond(e) ", TernaryExpr.class);
        Expr abCmp = abTernary.getPred();
        Expr bcCmp = bcTernary.getPred();
        Expr u1GetCondD = ((TernaryExpr) bcTernary.getIfTrue()).getPred();
        final MathExpr xxPlusU2getCondE = (MathExpr) bcTernary.getIfFalse();
        Expr u2GetCondE = xxPlusU2getCondE.getRight();
        Expr u1Name = abTernary.getIfTrue();
        Expr u2Name = abTernary.getIfFalse();
        Expr u1LastName = ((TernaryExpr) bcTernary.getIfTrue()).getIfTrue();
        Expr u2LastName = ((TernaryExpr) bcTernary.getIfTrue()).getIfFalse();

        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();

        assertExactMatch(shouldRead, a, b, c, abCmp, bcCmp);

        List<Expr> firstRead = getReadFirst(shouldRead);

        assertExactMatch(firstRead, a, b, c);

        assertFlags(a, a, b, u1, u2, u1Name, u2Name);
        assertFlags(b, a, b, u1, u2, u1Name, u2Name, c, d, u1LastName, u2LastName, e);
        assertFlags(c, b, c, u1, d, u1LastName, u2LastName, e);
        assertFlags(abCmp, a, b, u1, u2, u1Name, u2Name);
        assertFlags(bcCmp, b, c, u1, d, u1LastName, u2LastName, e);

        assertTrue(mExprModel.markBitsRead());

        shouldRead = getShouldRead();
        Expr[] batch = {d, e, u1, u2, u1GetCondD, u2GetCondE, xxPlusU2getCondE, abTernary,
                abTernary.getIfTrue(), abTernary.getIfFalse()};
        assertExactMatch(shouldRead, batch);
        firstRead = getReadFirst(shouldRead);
        assertExactMatch(firstRead, d, e, u1, u2);

        assertFlags(d, bcTernary.getRequirementFlagIndex(true));
        assertFlags(e, bcTernary.getRequirementFlagIndex(false));
        assertFlags(u1, bcTernary.getRequirementFlagIndex(true),
                abTernary.getRequirementFlagIndex(true));
        assertFlags(u2, bcTernary.getRequirementFlagIndex(false),
                abTernary.getRequirementFlagIndex(false));

        assertFlags(u1GetCondD, bcTernary.getRequirementFlagIndex(true));
        assertFlags(u2GetCondE, bcTernary.getRequirementFlagIndex(false));
        assertFlags(xxPlusU2getCondE, bcTernary.getRequirementFlagIndex(false));
        assertFlags(abTernary, a, b, u1, u2, u1Name, u2Name);
        assertFlags(abTernary.getIfTrue(), abTernary.getRequirementFlagIndex(true));
        assertFlags(abTernary.getIfFalse(), abTernary.getRequirementFlagIndex(false));

        assertTrue(mExprModel.markBitsRead());

        shouldRead = getShouldRead();

        assertExactMatch(shouldRead, u2, u1LastName, u2LastName, bcTernary.getIfTrue(), bcTernary);
        firstRead = getReadFirst(shouldRead);
        assertExactMatch(firstRead, u1LastName, u2);
        assertFlags(u2, bcTernary.getIfTrue().getRequirementFlagIndex(false));
        assertFlags(u1LastName, bcTernary.getIfTrue().getRequirementFlagIndex(true));
        assertFlags(u2LastName, bcTernary.getIfTrue().getRequirementFlagIndex(false));

        assertFlags(bcTernary.getIfTrue(), bcTernary.getRequirementFlagIndex(true));
        assertFlags(bcTernary, b, c, u1, u2, d, u1LastName, u2LastName, e);

        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testCircularDependency() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", int.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", int.class.getCanonicalName(),
                null);
        final TernaryExpr abTernary = parse(lb, "a > 3 ? a : b", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, abTernary.getPred());
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, b, abTernary);
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testNestedCircularDependency() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", int.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", int.class.getCanonicalName(),
                null);
        IdentifierExpr c = lb.addVariable("c", int.class.getCanonicalName(),
                null);
        final TernaryExpr a3Ternary = parse(lb, "a > 3 ? c > 4 ? a : b : c", TernaryExpr.class);
        final TernaryExpr c4Ternary = (TernaryExpr) a3Ternary.getIfTrue();
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, a3Ternary.getPred());
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, c, c4Ternary.getPred());
        assertFlags(c, a3Ternary.getRequirementFlagIndex(true),
                a3Ternary.getRequirementFlagIndex(false));
        assertFlags(c4Ternary.getPred(), a3Ternary.getRequirementFlagIndex(true));
    }

    @Test
    public void testInterExprDependency() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr u = lb.addVariable("u", User.class.getCanonicalName(),
                null);
        final Expr uComment = parse(lb, "u.comment", FieldAccessExpr.class);
        final TernaryExpr uTernary = parse(lb, "u.getUseComment ? u.comment : `xx`", TernaryExpr.class);
        mExprModel.seal();
        assertTrue(uTernary.getPred().canBeInvalidated());
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, u, uComment, uTernary.getPred());
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, uComment, uTernary);
    }

    @Test
    public void testInterExprCircularDependency() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", int.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", int.class.getCanonicalName(),
                null);
        final TernaryExpr abTernary = parse(lb, "a > 3 ? a : b", TernaryExpr.class);
        final TernaryExpr abTernary2 = parse(lb, "b > 3 ? b : a", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b, abTernary.getPred(), abTernary2.getPred());
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, abTernary, abTernary2);
    }

    @Test
    public void testInterExprCircularDependency2() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", boolean.class.getCanonicalName(),
                null);
        final TernaryExpr abTernary = parse(lb, "a ? b : true", TernaryExpr.class);
        final TernaryExpr baTernary = parse(lb, "b ? a : false", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b);
        assertFlags(a, a, b);
        assertFlags(b, a, b);
        List<Expr> readFirst = getReadFirst(shouldRead);
        assertExactMatch(readFirst, a, b);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, abTernary, baTernary);
        readFirst = getReadFirst(shouldRead);
        assertExactMatch(readFirst, abTernary, baTernary);
        assertFalse(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertEquals(0, shouldRead.size());
    }

    @Test
    public void testInterExprCircularDependency3() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr c = lb.addVariable("c", boolean.class.getCanonicalName(),
                null);
        final TernaryExpr abTernary = parse(lb, "a ? b : c", TernaryExpr.class);
        final TernaryExpr abTernary2 = parse(lb, "b ? a : c", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        // read a and b again, this time for their dependencies and also the rest since everything
        // is ready to be read
        assertExactMatch(shouldRead, c, abTernary, abTernary2);
        mExprModel.markBitsRead();
        shouldRead = getShouldRead();
        assertEquals(0, shouldRead.size());
    }

    @Test
    public void testInterExprCircularDependency4() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr b = lb.addVariable("b", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr c = lb.addVariable("c", boolean.class.getCanonicalName(),
                null);
        IdentifierExpr d = lb.addVariable("d", boolean.class.getCanonicalName(),
                null);
        final TernaryExpr cTernary = parse(lb, "c ? (a ? d : false) : false", TernaryExpr.class);
        final TernaryExpr abTernary = parse(lb, "a ? b : true", TernaryExpr.class);
        final TernaryExpr baTernary = parse(lb, "b ? a : false", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        // check if a,b or c should be read. these are easily calculated from binding expressions'
        // invalidation
        assertExactMatch(shouldRead, c, a, b);

        List<Expr> justRead = new ArrayList<Expr>();
        List<Expr> readFirst = getReadFirst(shouldRead);
        assertExactMatch(readFirst, c, a, b);
        Collections.addAll(justRead, a, b, c);
        assertEquals(0, filterOut(getReadFirst(shouldRead, justRead), justRead).size());
        assertTrue(mExprModel.markBitsRead());

        shouldRead = getShouldRead();
        // if a and b are not invalid, a won't be read in the first step. But if c's expression
        // is invalid and c == true, a must be read. Depending on a, d might be read as well.
        // don't need to read b anymore because `a ? b : true` and `b ? a : false` has the same
        // invalidation flags.
        assertExactMatch(shouldRead, a, baTernary);
        justRead.clear();

        readFirst = getReadFirst(shouldRead);
        // first must read `a`.
        assertExactMatch(readFirst, a);
        Collections.addAll(justRead, a);

        readFirst = filterOut(getReadFirst(shouldRead, justRead), justRead);
        assertExactMatch(readFirst, baTernary);
        Collections.addAll(justRead, baTernary);

        readFirst = filterOut(getReadFirst(shouldRead, justRead), justRead);
        assertEquals(0, filterOut(getReadFirst(shouldRead, justRead), justRead).size());
        assertTrue(mExprModel.markBitsRead());

        shouldRead = getShouldRead();
        // now we can read abTernary as well which had a conditional dependency on a but we did not
        // elevate its dependency since we had other expressions elevated already

        // now we can read adf ternary and c ternary
        justRead.clear();
        assertExactMatch(shouldRead, abTernary, d, cTernary.getIfTrue(), cTernary);
        readFirst = getReadFirst(shouldRead);
        assertExactMatch(readFirst, d, abTernary);
        Collections.addAll(justRead, d, abTernary);
        readFirst = filterOut(getReadFirst(shouldRead, justRead), justRead);
        assertExactMatch(readFirst, cTernary.getIfTrue());
        Collections.addAll(justRead, cTernary.getIfTrue());

        readFirst = filterOut(getReadFirst(shouldRead, justRead), justRead);
        assertExactMatch(readFirst, cTernary);
        Collections.addAll(justRead, cTernary);

        assertEquals(0, filterOut(getReadFirst(shouldRead, justRead), justRead).size());

        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testInterExprDeepDependency() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", boolean.class.getCanonicalName(), null);
        IdentifierExpr b = lb.addVariable("b", boolean.class.getCanonicalName(), null);
        IdentifierExpr c = lb.addVariable("c", boolean.class.getCanonicalName(), null);
        final TernaryExpr t1 = parse(lb, "c ? (a ? b : true) : false", TernaryExpr.class);
        final TernaryExpr t2 = parse(lb, "c ? (b ? a : false) : true", TernaryExpr.class);
        final TernaryExpr abTernary = (TernaryExpr) t1.getIfTrue();
        final TernaryExpr baTernary = (TernaryExpr) t2.getIfTrue();
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, c);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, b, t1.getIfTrue(), t2.getIfTrue(), t1, t2);
        assertFlags(b, abTernary.getRequirementFlagIndex(true));
        assertFlags(a, baTernary.getRequirementFlagIndex(true));
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testInterExprDependencyNotReadyYet() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr a = lb.addVariable("a", boolean.class.getCanonicalName(), null);
        IdentifierExpr b = lb.addVariable("b", boolean.class.getCanonicalName(), null);
        IdentifierExpr c = lb.addVariable("c", boolean.class.getCanonicalName(), null);
        IdentifierExpr d = lb.addVariable("d", boolean.class.getCanonicalName(), null);
        IdentifierExpr e = lb.addVariable("e", boolean.class.getCanonicalName(), null);
        final TernaryExpr cTernary = parse(lb, "c ? (a ? d : false) : false", TernaryExpr.class);
        final TernaryExpr baTernary = parse(lb, "b ? a : false", TernaryExpr.class);
        final TernaryExpr eaTernary = parse(lb, "e ? a : false", TernaryExpr.class);
        mExprModel.seal();
        List<Expr> shouldRead = getShouldRead();
        assertExactMatch(shouldRead, b, c, e);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, a, baTernary, eaTernary);
        assertTrue(mExprModel.markBitsRead());
        shouldRead = getShouldRead();
        assertExactMatch(shouldRead, d, cTernary.getIfTrue(), cTernary);
        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testInvalidateConditional() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final IdentifierExpr foo = lb.addVariable("foo", Foo.class.getCanonicalName(), null);
        final IdentifierExpr c = lb.addVariable("c", "int", null);
        final TernaryExpr ternary = parse(lb, "foo.a > 0 && (foo.b > 0 || c > 0)",
                TernaryExpr.class);
        final ComparisonExpr fooB0 = parse(lb, "foo.b > 0", ComparisonExpr.class);
        final FieldAccessExpr fooB = (FieldAccessExpr) fooB0.getLeft();
        mExprModel.seal();
        final ComparisonExpr fooA0 = (ComparisonExpr) ternary.getPred();
        final FieldAccessExpr fooA = (FieldAccessExpr) fooA0.getLeft();

        // foo.b > 0 || c > 0
        final TernaryExpr ternaryIfTrue = (TernaryExpr) ternary.getIfTrue();
        final ComparisonExpr c0 = (ComparisonExpr) ternaryIfTrue.getIfFalse();

        List<Expr> toRead = getShouldRead();
        assertExactMatch(toRead, foo, fooA, fooA0, fooB, fooB0);
        List<Expr> justRead = new ArrayList<Expr>();
        List<Expr> readNow = getReadFirst(toRead, justRead);
        assertExactMatch(readNow, foo);
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, fooA, fooB);
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, fooA0, fooB0);
        justRead.addAll(readNow);

        assertTrue(mExprModel.markBitsRead());
        justRead.clear();
        toRead = getShouldRead();

        // there is a second path to calculate fooB, fooB0 where fooB is not invalid but fooA or
        // c is invalid.
        assertExactMatch(toRead, fooB, fooB0);
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, fooB);
        justRead.add(fooB);
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, fooB0);

        assertTrue(mExprModel.markBitsRead());
        justRead.clear();
        toRead = getShouldRead();

        assertExactMatch(toRead, c, c0, ternary.getIfTrue(), ternary);
        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, c);
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, c0);
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, ternary.getIfTrue());
        justRead.addAll(readNow);

        readNow = filterOut(getReadFirst(toRead, justRead), justRead);
        assertExactMatch(readNow, ternary);
        justRead.addAll(readNow);

        assertFalse(mExprModel.markBitsRead());
    }

    @Test
    public void testNoFlagsForNonBindingStatic() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("a", int.class.getCanonicalName(), null);
        final MathExpr parsed = parse(lb, "a * (3 + 2)", MathExpr.class);
        mExprModel.seal();
        // +1 for invalidate all flag
        assertEquals(1, parsed.getRight().getInvalidFlags().cardinality());
        // +1 for invalidate all flag
        assertEquals(2, parsed.getLeft().getInvalidFlags().cardinality());
        // +1 for invalidate all flag
        assertEquals(2, mExprModel.getInvalidateableFieldLimit());
    }

    @Test
    public void testFlagsForBindingStatic() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("a", int.class.getCanonicalName(), null);
        final Expr staticParsed = parse(lb, "3 + 2", MathExpr.class);
        final MathExpr parsed = parse(lb, "a * (3 + 2)", MathExpr.class);
        mExprModel.seal();
        assertTrue(staticParsed.isBindingExpression());
        // +1 for invalidate all flag
        assertEquals(1, staticParsed.getInvalidFlags().cardinality());
        assertEquals(parsed.getRight().getInvalidFlags(), staticParsed.getInvalidFlags());
        // +1 for invalidate all flag
        assertEquals(2, parsed.getLeft().getInvalidFlags().cardinality());
        // +1 for invalidate all flag
        assertEquals(2, mExprModel.getInvalidateableFieldLimit());
    }

    @Test
    public void testFinalFieldOfAVariable() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        IdentifierExpr user = lb.addVariable("user", User.class.getCanonicalName(),
                null);
        Expr fieldGet = parse(lb, "user.finalField", FieldAccessExpr.class);
        mExprModel.seal();
        assertTrue(fieldGet.isDynamic());
        // read user
        assertExactMatch(getShouldRead(), user, fieldGet);
        mExprModel.markBitsRead();
        // no need to read user.finalField
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testFinalFieldOfAField() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("user", User.class.getCanonicalName(), null);
        Expr finalFieldGet = parse(lb, "user.subObj.finalField", FieldAccessExpr.class);
        mExprModel.seal();
        assertTrue(finalFieldGet.isDynamic());
        Expr userSubObjGet = finalFieldGet.getChildren().get(0);
        // read user
        List<Expr> shouldRead = getShouldRead();
        assertEquals(3, shouldRead.size());
        assertExactMatch(shouldRead, userSubObjGet.getChildren().get(0), userSubObjGet,
                finalFieldGet);
        mExprModel.markBitsRead();
        // no need to read user.subObj.finalField because it is final
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testFinalFieldOfAMethod() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("user", User.class.getCanonicalName(), null);
        Expr finalFieldGet = parse(lb, "user.anotherSubObj.finalField", FieldAccessExpr.class);
        mExprModel.seal();
        assertTrue(finalFieldGet.isDynamic());
        Expr userSubObjGet = finalFieldGet.getChildren().get(0);
        // read user
        List<Expr> shouldRead = getShouldRead();
        assertEquals(3, shouldRead.size());
        assertExactMatch(shouldRead, userSubObjGet.getChildren().get(0), userSubObjGet,
                finalFieldGet);
        mExprModel.markBitsRead();
        // no need to read user.subObj.finalField because it is final
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testFinalOfAClass() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        mExprModel.addImport("View", "android.view.View", null);
        FieldAccessExpr fieldAccess = parse(lb, "View.VISIBLE", FieldAccessExpr.class);
        assertFalse(fieldAccess.isDynamic());
        mExprModel.seal();
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testStaticFieldOfInstance() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("myView", "android.view.View", null);
        FieldAccessExpr fieldAccess = parse(lb, "myView.VISIBLE", FieldAccessExpr.class);
        assertFalse(fieldAccess.isDynamic());
        mExprModel.seal();
        assertEquals(0, getShouldRead().size());
        final Expr child = fieldAccess.getTarget();
        assertTrue(child instanceof StaticIdentifierExpr);
        StaticIdentifierExpr id = (StaticIdentifierExpr) child;
        assertEquals(id.getResolvedType().getCanonicalName(), "android.view.View");
        // on demand import
        assertEquals("android.view.View", mExprModel.getImports().get("View"));
    }

    @Test
    public void testOnDemandImportConflict() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final IdentifierExpr myView = lb.addVariable("u", "android.view.View",
                null);
        mExprModel.addImport("View", User.class.getCanonicalName(), null);
        final StaticIdentifierExpr id = mExprModel.staticIdentifierFor(myView.getResolvedType());
        mExprModel.seal();
        // on demand import with conflict
        assertEquals("android.view.View", mExprModel.getImports().get("View1"));
        assertEquals("View1", id.getName());
        assertEquals("android.view.View", id.getUserDefinedType());
    }

    @Test
    public void testOnDemandImportAlreadyImported() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final StaticIdentifierExpr ux = mExprModel.addImport("UX", User.class.getCanonicalName(),
                null);
        final IdentifierExpr u = lb.addVariable("u", User.class.getCanonicalName(),
                null);
        final StaticIdentifierExpr id = mExprModel.staticIdentifierFor(u.getResolvedType());
        mExprModel.seal();
        // on demand import with conflict
        assertSame(ux, id);
    }

    @Test
    public void testStaticMethodOfInstance() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        lb.addVariable("user", User.class.getCanonicalName(), null);
        MethodCallExpr methodCall = parse(lb, "user.ourStaticMethod()", MethodCallExpr.class);
        assertTrue(methodCall.isDynamic());
        mExprModel.seal();
        final Expr child = methodCall.getTarget();
        assertTrue(child instanceof StaticIdentifierExpr);
        StaticIdentifierExpr id = (StaticIdentifierExpr) child;
        assertEquals(id.getResolvedType().getCanonicalName(), User.class.getCanonicalName());
    }

    @Test
    public void testVoid() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "(v) -> cond1 ? obj4.clicked(v) : void", LambdaExpr.class);
        assertNotSame(mExprModel, lambda.getCallbackExprModel());
    }

    @Test
    public void testVoid2() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "(v) -> cond1 ? obj4.clicked(v) : Void", LambdaExpr.class);
        assertNotSame(mExprModel, lambda.getCallbackExprModel());
    }

    @Test
    public void testShruggy() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "(v) -> cond1 ? obj4.clicked(v) : ¯\\_(ツ)_/¯", LambdaExpr.class);
        assertNotSame(mExprModel, lambda.getCallbackExprModel());
    }

    @Test
    public void testParseNoArgLambda() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "() -> user.name", LambdaExpr.class);
        assertNotSame(mExprModel, lambda.getCallbackExprModel());
    }

    @Test
    public void testParseLambdaWithSingleArg() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "a -> user.name", LambdaExpr.class);
        assertNotSame(mExprModel, lambda.getCallbackExprModel());
        assertTrue("should have user", hasIdentifier(mExprModel, "user"));
        assertTrue("should have user", hasIdentifier(lambda.getCallbackExprModel(), "user"));
        assertSame("should have the same user", getIdentifier(mExprModel, "user"),
                getIdentifier(lambda.getCallbackExprModel(), "user"));
        assertTrue("should have a", hasCallbackIdentifier(lambda.getCallbackExprModel(), 0, "a"));
        assertFalse("should not have a", hasCallbackIdentifier(mExprModel, 0, "a"));
    }

    @Test
    public void testParseLambdaWithArguments() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final LambdaExpr lambda = parse(lb, "(a, b, c, d) -> user.name", LambdaExpr.class);
        final CallbackExprModel callbackModel = lambda.getCallbackExprModel();
        assertNotSame(mExprModel, callbackModel);
        assertTrue("should have user", hasIdentifier(mExprModel, "user"));
        int index = 0;
        for (String s : new String[]{"a", "b", "c", "d"}) {
            assertTrue("should have " + s, hasCallbackIdentifier(callbackModel, index, s));
            assertFalse("should not have " + s, hasIdentifier(mExprModel, s));
            assertFalse("should not have " + s, hasCallbackIdentifier(mExprModel, index, s));
            index ++;
        }
    }

    private boolean hasIdentifier(ExprModel model, String name) {
        return getIdentifier(model, name) != null;
    }

    private Expr getIdentifier(ExprModel model, String name) {
        return model.getExprMap().get(new IdentifierExpr(name).getUniqueKey());
    }

    private boolean hasCallbackIdentifier(ExprModel model, int index, String name) {
        return getCallbackIdentifier(model, index, name) != null;
    }

    private Expr getCallbackIdentifier(ExprModel model, int index, String name) {
        return model.getExprMap().get(new CallbackArgExpr(index, name).getUniqueKey());
    }


    @Test
    public void testFinalOfStaticField() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        mExprModel.addImport("UX", User.class.getCanonicalName(), null);
        FieldAccessExpr fieldAccess = parse(lb, "UX.innerStaticInstance.finalStaticField",
                FieldAccessExpr.class);
        assertFalse(fieldAccess.isDynamic());
        mExprModel.seal();
        // nothing to read since it is all final and static
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testFinalOfFinalStaticField() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        mExprModel.addImport("User", User.class.getCanonicalName(), null);
        FieldAccessExpr fieldAccess = parse(lb, "User.innerFinalStaticInstance.finalStaticField",
                FieldAccessExpr.class);
        assertFalse(fieldAccess.isDynamic());
        mExprModel.seal();
        assertEquals(0, getShouldRead().size());
    }

    @Test
    public void testLocationTracking() {
        MockLayoutBinder lb = new MockLayoutBinder();
        mExprModel = lb.getModel();
        final String input = "a > 3 ? b : c";
        TernaryExpr ternaryExpr = parse(lb, input, TernaryExpr.class);
        final Location location = ternaryExpr.getLocations().get(0);
        assertNotNull(location);
        assertEquals(0, location.startLine);
        assertEquals(0, location.startOffset);
        assertEquals(0, location.endLine);
        assertEquals(input.length() - 1, location.endOffset);

        final ComparisonExpr comparison = (ComparisonExpr) ternaryExpr.getPred();
        final Location predLoc = comparison.getLocations().get(0);
        assertNotNull(predLoc);
        assertEquals(0, predLoc.startLine);
        assertEquals(0, predLoc.startOffset);
        assertEquals(0, predLoc.endLine);
        assertEquals(4, predLoc.endOffset);

        final Location aLoc = comparison.getLeft().getLocations().get(0);
        assertNotNull(aLoc);
        assertEquals(0, aLoc.startLine);
        assertEquals(0, aLoc.startOffset);
        assertEquals(0, aLoc.endLine);
        assertEquals(0, aLoc.endOffset);

        final Location tLoc = comparison.getRight().getLocations().get(0);
        assertNotNull(tLoc);
        assertEquals(0, tLoc.startLine);
        assertEquals(4, tLoc.startOffset);
        assertEquals(0, tLoc.endLine);
        assertEquals(4, tLoc.endOffset);

        final Location bLoc = ternaryExpr.getIfTrue().getLocations().get(0);
        assertNotNull(bLoc);
        assertEquals(0, bLoc.startLine);
        assertEquals(8, bLoc.startOffset);
        assertEquals(0, bLoc.endLine);
        assertEquals(8, bLoc.endOffset);

        final Location cLoc = ternaryExpr.getIfFalse().getLocations().get(0);
        assertNotNull(cLoc);
        assertEquals(0, cLoc.startLine);
        assertEquals(12, cLoc.startOffset);
        assertEquals(0, cLoc.endLine);
        assertEquals(12, cLoc.endOffset);
    }

//    TODO uncomment when we have inner static access
//    @Test
//    public void testFinalOfInnerStaticClass() {
//        MockLayoutBinder lb = new MockLayoutBinder();
//        mExprModel = lb.getModel();
//        mExprModel.addImport("User", User.class.getCanonicalName());
//        FieldAccessExpr fieldAccess = parse(lb, "User.InnerStaticClass.finalStaticField", FieldAccessExpr.class);
//        assertFalse(fieldAccess.isDynamic());
//        mExprModel.seal();
//        assertEquals(0, getShouldRead().size());
//    }

    private void assertFlags(Expr a, int... flags) {
        BitSet bitset = new BitSet();
        for (int flag : flags) {
            bitset.set(flag);
        }
        assertEquals("flag test for " + a.getUniqueKey(), bitset, a.getShouldReadFlags());
    }

    private void assertFlags(Expr a, Expr... exprs) {
        BitSet bitSet = a.getShouldReadFlags();
        for (Expr expr : exprs) {
            BitSet clone = (BitSet) bitSet.clone();
            clone.and(expr.getInvalidFlags());
            assertEquals("should read flags of " + a.getUniqueKey() + " should include " + expr
                    .getUniqueKey(), expr.getInvalidFlags(), clone);
        }

        BitSet composite = new BitSet();
        for (Expr expr : exprs) {
            composite.or(expr.getInvalidFlags());
        }
        assertEquals("composite flags should match", composite, bitSet);
    }

    private void assertExactMatch(List<Expr> iterable, Expr... exprs) {
        int i = 0;
        String listLog = Arrays.toString(iterable.toArray());
        String itemsLog = Arrays.toString(exprs);
        String log = "list: " + listLog + "\nitems: " + itemsLog;
        log("list", iterable);
        for (Expr expr : exprs) {
            assertTrue((i++) + ":must contain " + expr.getUniqueKey() + "\n" + log,
                    iterable.contains(expr));
        }
        i = 0;
        for (Expr expr : iterable) {
            assertTrue((i++) + ":must be expected " + expr.getUniqueKey() + "\n" + log,
                    Arrays.asList(exprs).contains(expr));
        }
    }

    private <T extends Expr> T parse(LayoutBinder binder, String input, Class<T> klass) {
        final Expr parsed = binder.parse(input, null, null);
        assertTrue(klass.isAssignableFrom(parsed.getClass()));
        return (T) parsed;
    }

    private void log(String s, List<Expr> iterable) {
        L.d(s);
        for (Expr e : iterable) {
            L.d(": %s : %s allFlags: %s readSoFar: %s", e.getUniqueKey(), e.getShouldReadFlags(),
                    e.getShouldReadFlagsWithConditionals(), e.getReadSoFar());
        }
        L.d("end of %s", s);
    }

    private List<Expr> getReadFirst(List<Expr> shouldRead) {
        return getReadFirst(shouldRead, null);
    }

    private List<Expr> getReadFirst(List<Expr> shouldRead, final List<Expr> justRead) {
        List<Expr> result = new ArrayList<Expr>();
        for (Expr expr : shouldRead) {
            if (expr.shouldReadNow(justRead)) {
                result.add(expr);
            }
        }
        return result;
    }

    private List<Expr> getShouldRead() {
        return ExprModel.filterShouldRead(mExprModel.getPendingExpressions());
    }

    public static class Foo {
        public final int a = 1;
        public final int b = 1;
    }

    public static class User implements Observable {

        String name;

        String lastName;

        public final int finalField = 5;

        public static InnerStaticClass innerStaticInstance = new InnerStaticClass();

        public static final InnerStaticClass innerFinalStaticInstance = new InnerStaticClass();

        public SubObj subObj = new SubObj();

        public String getName() {
            return name;
        }

        public String getLastName() {
            return lastName;
        }

        public boolean getCond(int i) {
            return true;
        }

        public SubObj getAnotherSubObj() {
            return new SubObj();
        }

        public static boolean ourStaticMethod() {
            return true;
        }

        public String comment;

        @Bindable
        public boolean getUseComment() {
            return true;
        }

        @Override
        public void addOnPropertyChangedCallback(OnPropertyChangedCallback callback) {

        }

        @Override
        public void removeOnPropertyChangedCallback(OnPropertyChangedCallback callback) {

        }

        public static class InnerStaticClass {

            public static final int finalField = 3;

            public static final int finalStaticField = 3;
        }
    }

    public static class SubObj {

        public final int finalField = 5;
    }

}