/*
 * Copyright (c) 2013 QNX Software Systems and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 */
package org.eclipse.cdt.qt.tests;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.index.IIndexName;
import org.eclipse.cdt.core.index.IndexFilter;
import org.eclipse.cdt.internal.qt.core.index.IQEnum;
import org.eclipse.cdt.internal.qt.core.index.IQMethod;
import org.eclipse.cdt.internal.qt.core.index.IQObject;
import org.eclipse.cdt.internal.qt.core.index.IQProperty;
import org.eclipse.cdt.internal.qt.core.index.QtIndex;
import org.eclipse.cdt.internal.qt.core.index.IQProperty.Attribute;

public class QObjectTests extends BaseQtTestCase {

	// #include "junit-QObject.hh"
	// class T {};
	// class B1 : public QObject {Q_OBJECT};
	// class B2 : public QObject {Q_OBJECT};
	// class B3 : public QObject {Q_OBJECT};
	// class D1 : public B1, public B2, private B3, public T {Q_OBJECT};
	// class D2 : public T,  public QObject {};
	public void testGetBases() throws Exception {
		loadComment("bases.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj_B1 = qtIndex.findQObject(new String[]{ "B1" });
		if (!isIndexOk("B1", qobj_B1))
			return;
		IQObject qobj_D1 = qtIndex.findQObject(new String[]{ "D1" });
		assertNotNull(qobj_B1);
		assertNotNull(qobj_D1);

		Collection<IQObject> d1_bases = qobj_D1.getBases();
		assertNotNull(d1_bases);
		assertEquals(2, d1_bases.size());
		Iterator<IQObject> iterator = d1_bases.iterator();
		assertEquals(qobj_B1.getName(), iterator.next().getName());
		assertEquals("B2", iterator.next().getName());

		// D2 is not a QObject because it doesn't expand the Q_OBJECT macro
		IQObject qobj_D2 = qtIndex.findQObject(new String[]{ "D2" });
		assertNull(qobj_D2);
	}

	// #include "junit-QObject.hh"
	// class Q0 : public QObject
	// {
	// Q_OBJECT
	// public:
	//     enum EB { eb0 = 0xff };
	// };
	// class Q : public QObject
	// {
	// Q_OBJECT
	//
	// enum E0 { e0a, e0b };
	//
	// Q_ENUMS( E0 Q0::EB )
	// Q_ENUMS( E1 )
	//
	// enum E1 { e1a, e1b = 2 };
	// };
	public void testEnums() throws Exception {
		loadComment("qenums.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "Q" });
		if (!isIndexOk("Q", qobj))
			return;
		assertNotNull(qobj);

		Collection<IQEnum> qEnums = qobj.getEnums();
		assertNotNull(qEnums);
		assertEquals(3, qEnums.size());
		for(IQEnum qEnum : qEnums) {
			String name = qEnum.getName();
			assertFalse(qEnum.isFlag());
			if ("E0".equals(name)) {
				Collection<IQEnum.Enumerator> enumerators = qEnum.getEnumerators();
				assertNotNull(enumerators);
				assertEquals(2, enumerators.size());
				for (IQEnum.Enumerator enumerator : enumerators) {
					Long ordinal = enumerator.getOrdinal();
					if (Long.valueOf(0).equals(ordinal))
						assertEquals("e0a", enumerator.getName());
					else if (Long.valueOf(1).equals(ordinal))
						assertEquals("e0b", enumerator.getName());
					else
						fail("unexpected " + name + "::" + enumerator.getName() + " = " + String.valueOf(ordinal));
				}
			} else if("E1".equals(name)) {
				Collection<IQEnum.Enumerator> enumerators = qEnum.getEnumerators();
				assertNotNull(enumerators);
				assertEquals(2, enumerators.size());
				for (IQEnum.Enumerator enumerator : enumerators) {
					Long ordinal = enumerator.getOrdinal();
					if (Long.valueOf(0).equals(ordinal))
						assertEquals("e1a", enumerator.getName());
					else if (Long.valueOf(2).equals(ordinal))
						assertEquals("e1b", enumerator.getName());
					else
						fail("unexpected " + name + "::" + enumerator.getName() + " = " + String.valueOf(ordinal));
				}
			} else if("Q0::EB".equals(name)) {
				Collection<IQEnum.Enumerator> enumerators = qEnum.getEnumerators();
				assertNotNull(enumerators);
				assertEquals(1, enumerators.size());
				for (IQEnum.Enumerator enumerator : enumerators) {
					Long ordinal = enumerator.getOrdinal();
					if (Long.valueOf(255).equals(ordinal))
						assertEquals("eb0", enumerator.getName());
					else
						fail("unexpected " + name + "::" + enumerator.getName() + " = " + String.valueOf(ordinal));
				}
			} else {
				fail("unexpected Q_ENUM " + name);
			}
		}
	}

	// #include "junit-QObject.hh"
	// class Q : public QObject
	// {
	// Q_OBJECT
	// enum Enum { e0 };
	// Q_DECLARE_FLAGS(Flag, Enum)
	// Q_FLAGS(Flag);
	// enum Enum2 { e2 };
	// Q_FLAGS(Flag2);
	// Q_DECLARE_FLAGS(Flag2, Enum2)
	// Q_DECLARE_FLAGS(Flag2b, Enum2)
	// enum Enum3 { e3 };
	// Q_DECLARE_FLAGS(Flag3, Enum3)
	// };
	public void testFlags() throws Exception {
		loadComment("qflags.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "Q" });
		if (!isIndexOk("Q", qobj))
			return;
		assertNotNull(qobj);

		Collection<IQEnum> qEnums = qobj.getEnums();
		assertNotNull(qEnums);
		assertEquals(2, qEnums.size());

		for(IQEnum qEnum : qEnums) {
			assertNotNull(qEnum);
			assertTrue(qEnum.isFlag());
			if ("Flag".equals(qEnum.getName())) {
				Collection<IQEnum.Enumerator> enumerators = qEnum.getEnumerators();
				assertNotNull(enumerators);
				assertEquals(1, enumerators.size());
				assertEquals("e0", enumerators.iterator().next().getName());
			} else if("Flag2".equals(qEnum.getName())) {
				Collection<IQEnum.Enumerator> enumerators = qEnum.getEnumerators();
				assertNotNull(enumerators);
				assertEquals(1, enumerators.size());
				assertEquals("e2", enumerators.iterator().next().getName());
			} else
				fail("unexpected Q_FLAGS " + qEnum.getName());
		}
	}

    // #include "junit-QObject.hh"
    // class B : public QObject
    // {
    // Q_OBJECT
    // Q_PROPERTY(bool allowed READ isAllowed)
    // public:
    //     bool isAllowed() const { return false; }
    // };
	public void testOwner() throws Exception {
		loadComment("owner.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "B" });
		if (!isIndexOk("B", qobj))
			return;
		assertNotNull(qobj);

		Collection<IQProperty> properties = qobj.getProperties().locals();
		assertNotNull(properties);
		assertEquals(1, properties.size());

		IQProperty property = properties.iterator().next();
		assertNotNull(property);
		assertTrue(qobj == property.getOwner());
	}

	// #include "junit-QObject.hh"
	// template <typename T> class T {};
	// class Q : public QObject
	// {
	// Q_OBJECT
	//
	//     bool getProp() const;
	//
	// // strange cases found by grep'ing for Q_PROPERTY in the qt4 headers
	// Q_PROPERTY( bool prop1 READ getProp )
	// Q_PROPERTY( T<bool> prop2 READ getProp )
	// Q_PROPERTY( T<bool *> prop3 READ getProp )
	// Q_PROPERTY( bool *prop4 READ getProp )
	// Q_PROPERTY( bool prop5 )
	// Q_PROPERTY( bool *prop6 )
	//
	// Q_PROPERTY( bool read1 READ readMethod )
	// Q_PROPERTY( bool read2 READ readMethod2 FINAL )
	//
	// // from qtoolbar.h
	// Q_PROPERTY( Namespace::Type  allowedAreas1 )
	// Q_PROPERTY( Qt::ToolBarAreas allowedAreas2 READ allowedAreas WRITE setAllowedAreas
	//             DESIGNABLE (qobject_cast<QMainWindow *>(parentWidget()) != 0)
	//             NOTIFY allowedAreasChanged )
	//
	//     bool readMethod();
	//     bool readMethod2() const { return false; }
	//     Qt::ToolBarAreas allowedAreas() const;
	//     void setAllowedAreas( Qt::ToolBarAreas ) { }
	//     Q_SIGNAL void allowedAreasChanged();
	// };
	public void testQProperties() throws Exception {
		loadComment("q_property.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "Q" });
		if (!isIndexOk("Q", qobj))
			return;
		assertNotNull(qobj);

		assert_checkQProperties(
			qobj,
			new ExpectedQProperty("bool",      "prop1", Attribute.READ, "getProp"),
			new ExpectedQProperty("T<bool>",   "prop2", Attribute.READ, "getProp"),
			new ExpectedQProperty("T<bool *>", "prop3", Attribute.READ, "getProp"),
			new ExpectedQProperty("bool *",    "prop4", Attribute.READ, "getProp"),
			new ExpectedQProperty("bool",      "prop5"),
			new ExpectedQProperty("bool *",    "prop6"),

			new ExpectedQProperty("bool", "read1", Attribute.READ, "readMethod"),
			new ExpectedQProperty("bool", "read2", Attribute.READ ,"readMethod2", Attribute.FINAL),

			new ExpectedQProperty("Namespace::Type",    "allowedAreas1" ),
			new ExpectedQProperty("Qt::ToolBarAreas",   "allowedAreas2",
							      Attribute.READ,       "allowedAreas",
							      Attribute.WRITE,      "setAllowedAreas",
							      Attribute.DESIGNABLE, "(qobject_cast<QMainWindow *>(parentWidget()) != 0)",
							      Attribute.NOTIFY,     "allowedAreasChanged")
		);
	}

    // #include "junit-QObject.hh"
    // class B : public QObject
    // {
    // Q_OBJECT
    // Q_PROPERTY(bool allowed READ isAllowed)
    // public:
    //     bool isAllowed() const { return false; }
    // };
    // class D1 : public B
    // {
    // Q_OBJECT
    // Q_PROPERTY(bool allowed READ isAllowed_d)
    // public:
    //     bool isAllowed_d() const { return false; }
    // };
	public void testGetOverridden() throws Exception {
		loadComment("getOverridden.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject base_qobj = qtIndex.findQObject(new String[]{ "B" });
		if (!isIndexOk("B", base_qobj))
			return;
		assertNotNull(base_qobj);

		IQObject.IMembers<IQProperty> base_qprops = base_qobj.getProperties();
		assertNotNull(base_qprops);
		assertEquals(1, base_qprops.all().size());
		assertEquals(1, base_qprops.locals().size());
		assertEquals(1, base_qprops.withoutOverrides().size());

		IQObject derived_qobj1 = qtIndex.findQObject(new String[]{ "D1" });
		assertNotNull(derived_qobj1);
		IQObject.IMembers<IQProperty> derived_qprops1 = derived_qobj1.getProperties();
		assertNotNull(derived_qprops1);
		assertEquals(2, derived_qprops1.all().size());
		assertEquals(1, derived_qprops1.locals().size());
		assertEquals(1, derived_qprops1.withoutOverrides().size());
	}

    // #include "junit-QObject.hh"
    // class B : public QObject
    // {
    // Q_OBJECT
    // Q_CLASSINFO( "key1", "value1" )
    // Q_CLASSINFO( "key2", "value\"2" )
    // public:
    //     bool isAllowed() const { return false; }
    // };
    // class D : public B
    // {
    // Q_OBJECT
    // Q_CLASSINFO( "key2", "overridden value" )
    // public:
    //     bool isAllowed() const { return false; }
    // };
	public void testClassInfos() throws Exception {
		loadComment("classinfos.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj_b = qtIndex.findQObject(new String[]{ "B" });
		if (!isIndexOk("B", qobj_b))
			return;
		assertNotNull(qobj_b);
		assertEquals("value1", qobj_b.getClassInfo("key1"));
		assertEquals("value\\\"2", qobj_b.getClassInfo("key2"));

		IQObject qobj_d = qtIndex.findQObject(new String[]{ "D" });
		assertNotNull(qobj_d);
		assertEquals("value1", qobj_d.getClassInfo("key1")); // inherited
		assertEquals("overridden value", qobj_d.getClassInfo("key2"));
	}

	private static class ExpectedQProperty {
		public final String type;
		public final String name;
		Object[] attributes;
		public ExpectedQProperty(String type, String name, Object... attributes) {
			this.type = type;
			this.name = name;
			this.attributes = attributes;
		}
	}

	/**
	 * A utility method for testing Q_PROPERTYs.  The given object is checked for the list of
	 * values.  Only the locally declared properties are checked and the list must be complete.
	 */
	private static void assert_checkQProperties(IQObject qobj, ExpectedQProperty... expectedProperties) throws Exception {

		// this map is used to make sure that all expected attributes are found
		Map<String, ExpectedQProperty> qprops = new HashMap<String, QObjectTests.ExpectedQProperty>();
		for(ExpectedQProperty qprop : expectedProperties)
			if (qprops.containsKey(qprop.name))
				fail("duplicate properties in expected list " + qprop.name);
			else
				qprops.put(qprop.name, qprop);

		for(IQProperty qprop : qobj.getProperties().locals()) {
			ExpectedQProperty expected = qprops.remove(qprop.getName());
			assertNotNull("unexpected or duplicate attribute " + qprop.getName(), expected);
			assertEquals("unexpected type for " + expected.name, expected.type, qprop.getType());
			assertEquals("unexpected type for " + expected.name, expected.name, qprop.getName());

			// make sure that all attributes that were found were expected
			Set<Attribute> allAttrs = new HashSet<Attribute>(Arrays.asList(Attribute.values()));

			for(int i = 0; i < expected.attributes.length; ++i) {
				Attribute attr = (Attribute)expected.attributes[i];

				// make sure the test is valid -- search for each attribute at most once
				assertTrue(allAttrs.remove(attr));

				if (!attr.hasValue)
					assertNotNull("missing " + attr.toString(), attr.valueIn(qprop));
				else if(i >= (expected.attributes.length - 1)
					 || expected.attributes[i + 1] instanceof Attribute)
					fail("INVALID TEST CASE: " + attr + " should have a value, but one was not provided" );
				else {
					Object exp = expected.attributes[++i];
					assertEquals(attr.toString(), exp, attr.valueIn(qprop));
				}
			}

			// make sure there is no value for all other attributes
			for(Attribute attr : allAttrs)
				assertTrue("unexpectedly found value for " + attr, attr.valueIn(qprop) == null);
		}

		// make sure that all expected properties were found
		StringBuilder missingAttrs = new StringBuilder();
		for(String propName : qprops.keySet()) {
			if (missingAttrs.length() > 0)
				missingAttrs.append(", ");
			missingAttrs.append(propName);
		}
		assertTrue("missing properties " + missingAttrs.toString(), missingAttrs.length() == 0);
	}

	// #include "junit-QObject.hh"
    // class Q : public QObject
    // {
    // Q_OBJECT
	// signals:
	// public:    void notASignal();
	// Q_SIGNALS: void signal();
	// public:    void notAnotherSignal();
	// Q_SIGNAL   void anotherSignal();
    // };
	public void testSimpleSignal() throws Exception {
		loadComment("simple_signal.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "Q" });
		if (!isIndexOk("Q", qobj))
			return;
		assertNotNull(qobj);

		IQObject.IMembers<IQMethod> signals = qobj.getSignals();
		assertNotNull(signals);

		Collection<IQMethod> locals = signals.locals();
		assertNotNull(locals);

		Iterator<IQMethod> i = locals.iterator();
		assertTrue(i.hasNext());
		assert_checkQMethod(i.next(), qobj, "signal", IQMethod.Kind.Signal, null);
		assertTrue(i.hasNext());
		assert_checkQMethod(i.next(), qobj, "anotherSignal", IQMethod.Kind.Signal, null);
		assertFalse(i.hasNext());
	}

	// #include "junit-QObject.hh"
    // namespace N {
	//     class Q : public QObject
    //     {
    //     Q_OBJECT
	//     Q_SIGNAL void aSignal();
    //     };
	// }
	public void testQObjectInNamespace() throws Exception {
		loadComment("namespace_qobj.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "N", "Q" });
		if (!isIndexOk("N::Q", qobj))
			return;
		assertNotNull(qobj);

		IQObject.IMembers<IQMethod> signals = qobj.getSignals();
		assertNotNull(signals);

		Collection<IQMethod> locals = signals.locals();
		assertNotNull(locals);

		Iterator<IQMethod> i = locals.iterator();
		assertTrue(i.hasNext());
		assert_checkQMethod(i.next(), qobj, "aSignal", IQMethod.Kind.Signal, null);
		assertFalse(i.hasNext());
	}

	private static void assert_checkQMethod(IQMethod method, IQObject expectedOwner, String expectedName, IQMethod.Kind expectedKind, Long expectedRevision) throws Exception {
		assertEquals(expectedKind, method.getKind());
		assertEquals(expectedName, method.getName());
		assertSame(method.getName(), expectedOwner, method.getOwner());
		assertEquals(expectedRevision, method.getRevision());
	}

	// #include "junit-QObject.hh"
    // class Q : public QObject
    // {
    // Q_OBJECT
	//
    // // From the QML test suite -- this is not valid C++.  The Qt moc generates duplicate const,
	// // but our CDT-based implementation is not able to do the same.  Instead we generate what
	// // would be the correct C++ signature.
    // Q_INVOKABLE void someFunc(const QList<const QString const*> const &p1, QString p2 = "Hello");
    //
    // // variations on the above
    // Q_INVOKABLE void someFunc1(const QList<const QString const*> &p1, QString p2 = "Hello");
    // Q_INVOKABLE void someFunc2(QList<const QString const*> const &p1, QString p2 = "Hello");
    // Q_INVOKABLE void someFunc3(const QList<const QString *> &p1, QString p2 = "Hello");
    // Q_INVOKABLE void someFunc4(const QList<QString const*> &p1, QString p2 = "Hello");
    // Q_INVOKABLE void someFunc5(const QList<const QString *> &p1, QString p2 = "Hello") const;
    // Q_INVOKABLE void someFunc6(const QList<QString *const> &p1, QString p2 = "Hello");
    // };
	public void testInvokables() throws Exception {
		loadComment("invokables.hh");

		QtIndex qtIndex = QtIndex.getIndex(fProject);
		assertNotNull(qtIndex);

		IQObject qobj = qtIndex.findQObject(new String[]{ "Q" });
		if (!isIndexOk("Q", qobj))
			return;
		assertNotNull(qobj);

		IQObject.IMembers<IQMethod> invokables = qobj.getInvokables();
		assertNotNull(invokables);
		assertEquals(7, invokables.locals().size());

		for(IQMethod invokable : invokables.locals()) {

			assertTrue(invokable.getName(), qobj == invokable.getOwner());
			assertEquals(invokable.getName(), IQMethod.Kind.Invokable, invokable.getKind());
			assertNull(invokable.getRevision());

			if ("someFunc".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc(QList<const QString*>,QString)"));
			else if ("someFunc1".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc1(QList<const QString*>,QString)"));
			else if ("someFunc2".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc2(QList<const QString*>,QString)"));
			else if ("someFunc3".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc3(QList<const QString*>,QString)"));
			else if ("someFunc4".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc4(QList<const QString*>,QString)"));
			else if ("someFunc5".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc5(QList<const QString*>,QString)"));
			else if ("someFunc6".equals(invokable.getName()))
				assertTrue(invokable.getSignatures().contains("someFunc6(QList<QString*const>,QString)"));
			else
				fail("unexpected invokable " + invokable.getName());
		}
	}

	// #include "junit-QObject.hh"
	// class QUnrelated : public QObject { Q_OBJECT };
	// class Q : public QObject
	// {
	// Q_OBJECT
	// Q_SIGNAL void signal1();
	// Q_SLOT void slot1();
	//
	//     void f1();
	//     void f2()
	//     {
	//         Q q, *q_sender = this, *q_receiver = this;
	//         QUnrelated *q_unrelated;
	//         QMetaMethod meta = q.metaObject()->method( 0 );
	//
	//         //    static bool connect(const QObject *sender, const char *signal,
	//         //                        const QObject *receiver, const char *member,
	//         //                        Qt::ConnectionType = Qt::AutoConnection);
	//         QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//         QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//         QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()), Qt::AutoConnection );
	//         QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()), Qt::AutoConnection );
	//         q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//         q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//         q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()), Qt::AutoConnection );
	//         q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()), Qt::AutoConnection );
	//
	//         //    static bool connect(const QObject *sender, const QMetaMethod &signal,
	//         //                        const QObject *receiver, const QMetaMethod &method,
	//         //                        Qt::ConnectionType type = Qt::AutoConnection);
	//         QObject::connect( q_sender, meta, q_receiver, meta );
	//         QObject::connect( q_sender, meta, q_receiver, meta, Qt::AutoConnection );
	//         q_unrelated->connect( q_sender, meta, q_receiver, meta );
	//         q_unrelated->connect( q_sender, meta, q_receiver, meta, Qt::AutoConnection );
	//
	//         //    inline bool connect(const QObject *sender, const char *signal,
	//         //                        const char *member,
	//         //                        Qt::ConnectionType type = Qt::AutoConnection) const;
	//         q_receiver->connect( q_sender, SIGNAL(signal1()), SIGNAL(signal1()) );
	//         q_receiver->connect( q_sender, SIGNAL(signal1()), SLOT(slot1()) );
	//         q_receiver->connect( q_sender, SIGNAL(signal1()), SIGNAL(signal1()), Qt::AutoConnection );
	//         q_receiver->connect( q_sender, SIGNAL(signal1()), SLOT(slot1()), Qt::AutoConnection );
	//
	//         //    static bool disconnect(const QObject *sender, const char *signal,
	//         //                           const QObject *receiver, const char *member);
	//         QObject::disconnect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//         QObject::disconnect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//         q_unrelated->disconnect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//         q_unrelated->disconnect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//
	//         //    static bool disconnect(const QObject *sender, const QMetaMethod &signal,
	//         //                           const QObject *receiver, const QMetaMethod &member);
	//         QObject::disconnect( q_sender, meta, q_receiver, meta );
	//         q_unrelated->disconnect( q_sender, meta, q_receiver, meta );
	//
	//         //    inline bool disconnect(const char *signal = 0,
	//         //                           const QObject *receiver = 0, const char *member = 0);
	//         q_sender->disconnect( SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//         q_sender->disconnect( SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//         q_sender->disconnect( SIGNAL(signal1()), q_receiver );
	//         q_sender->disconnect( SIGNAL(signal1()) );
	//         q_sender->disconnect();
	//
	//         //    inline bool disconnect(const QObject *receiver, const char *member = 0);
	//         q_sender->disconnect( q_receiver, SIGNAL(signal1()) );
	//         q_sender->disconnect( q_receiver, SLOT(slot1()) );
	//         q_sender->disconnect( q_receiver );
	//     }
	// };
	// // This is exactly the same as the inline function body.  It is duplicated here because of
	// // an old bug where the function definitions were not properly indexed (for Qt).
	// void Q::f1()
	// {
	//     Q q, *q_sender = this, *q_receiver = this;
	//     QUnrelated *q_unrelated;
	//     QMetaMethod meta = q.metaObject()->method( 0 );
	//
	//     //    static bool connect(const QObject *sender, const char *signal,
	//     //                        const QObject *receiver, const char *member,
	//     //                        Qt::ConnectionType = Qt::AutoConnection);
	//     QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//     QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//     QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()), Qt::AutoConnection );
	//     QObject::connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()), Qt::AutoConnection );
	//     q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//     q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//     q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()), Qt::AutoConnection );
	//     q_unrelated->connect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()), Qt::AutoConnection );
	//
	//     //    static bool connect(const QObject *sender, const QMetaMethod &signal,
	//     //                        const QObject *receiver, const QMetaMethod &method,
	//     //                        Qt::ConnectionType type = Qt::AutoConnection);
	//     QObject::connect( q_sender, meta, q_receiver, meta );
	//     QObject::connect( q_sender, meta, q_receiver, meta, Qt::AutoConnection );
	//     q_unrelated->connect( q_sender, meta, q_receiver, meta );
	//     q_unrelated->connect( q_sender, meta, q_receiver, meta, Qt::AutoConnection );
	//
	//     //    inline bool connect(const QObject *sender, const char *signal,
	//     //                        const char *member,
	//     //                        Qt::ConnectionType type = Qt::AutoConnection) const;
	//     q_receiver->connect( q_sender, SIGNAL(signal1()), SIGNAL(signal1()) );
	//     q_receiver->connect( q_sender, SIGNAL(signal1()), SLOT(slot1()) );
	//     q_receiver->connect( q_sender, SIGNAL(signal1()), SIGNAL(signal1()), Qt::AutoConnection );
	//     q_receiver->connect( q_sender, SIGNAL(signal1()), SLOT(slot1()), Qt::AutoConnection );
	//
	//     //    static bool disconnect(const QObject *sender, const char *signal,
	//     //                           const QObject *receiver, const char *member);
	//     QObject::disconnect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//     QObject::disconnect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//     q_unrelated->disconnect( q_sender, SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//     q_unrelated->disconnect( q_sender, SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//
	//     //    static bool disconnect(const QObject *sender, const QMetaMethod &signal,
	//     //                           const QObject *receiver, const QMetaMethod &member);
	//     QObject::disconnect( q_sender, meta, q_receiver, meta );
	//     q_unrelated->disconnect( q_sender, meta, q_receiver, meta );
	//
	//     //    inline bool disconnect(const char *signal = 0,
	//     //                           const QObject *receiver = 0, const char *member = 0);
	//     q_sender->disconnect( SIGNAL(signal1()), q_receiver, SIGNAL(signal1()) );
	//     q_sender->disconnect( SIGNAL(signal1()), q_receiver, SLOT(slot1()) );
	//     q_sender->disconnect( SIGNAL(signal1()), q_receiver );
	//     q_sender->disconnect( SIGNAL(signal1()) );
	//     q_sender->disconnect();
	//
	//     //    inline bool disconnect(const QObject *receiver, const char *member = 0);
	//     q_sender->disconnect( q_receiver, SIGNAL(signal1()) );
	//     q_sender->disconnect( q_receiver, SLOT(slot1()) );
	//     q_sender->disconnect( q_receiver );
	// }
	public void testSignalSlotReferences() throws Exception {
		loadComment("sig_slot_refs.hh");
		waitForIndexer(fCProject);

		// References are from the function's IBinding.
		assertNotNull(fIndex);
		fIndex.acquireReadLock();
		try {
			char[][] Q_signal1_qn = new char[][]{ "Q".toCharArray(), "signal1".toCharArray() };
			IIndexBinding[] Q_signal1s = fIndex.findBindings(Q_signal1_qn, IndexFilter.CPP_DECLARED_OR_IMPLICIT, npm());
			assertNotNull(Q_signal1s);
			assertEquals(1, Q_signal1s.length);
			IIndexBinding Q_signal1 = Q_signal1s[0];
			assertNotNull(Q_signal1);

			char[][] Q_slot1_qn = new char[][]{ "Q".toCharArray(), "slot1".toCharArray() };
			IIndexBinding[] Q_slot1s = fIndex.findBindings(Q_slot1_qn, IndexFilter.CPP_DECLARED_OR_IMPLICIT, npm());
			assertNotNull(Q_slot1s);
			assertEquals(1, Q_slot1s.length);
			IIndexBinding Q_slot1 = Q_slot1s[0];
			assertNotNull(Q_slot1);

			// Each valid variant of the connect function call should have one reference
			// in the inline function (f2) and one reference in the function with a separate
			// definition (f1).
			int expectedSignalRefs = 2 * 30;
			int expectedSlotRefs = 2 * 10;

			IIndexName[] signalRefs = fIndex.findReferences(Q_signal1);
			assertNotNull(signalRefs);
			assertEquals(expectedSignalRefs, signalRefs.length);

			IIndexName[] slotRefs = fIndex.findReferences(Q_slot1);
			assertNotNull(slotRefs);
			assertEquals(expectedSlotRefs, slotRefs.length);
		} finally {
			fIndex.releaseReadLock();
		}
	}
}