@NotNull
public static Collection<FqName> getTopLevelFunctionFqNames(
@NotNull Project project, @NotNull GlobalSearchScope scope, boolean shouldBeExtension) {
Collection<FqName> result = Sets.newHashSet();
Collection<PsiClass> packageClasses =
getClassesByAnnotation(KotlinPackage.class.getSimpleName(), project, scope);
for (PsiClass psiClass : packageClasses) {
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName == null) {
continue;
}
FqName packageFqName = new FqName(qualifiedName).parent();
PackageData data = getPackageData(psiClass);
if (data == null) {
continue;
}
NameResolver nameResolver = data.getNameResolver();
for (ProtoBuf.Callable callable : data.getPackageProto().getMemberList()) {
if (callable.hasReceiverType() == shouldBeExtension) {
Name name = nameResolver.getName(callable.getName());
result.add(packageFqName.child(name));
}
}
}
return result;
}
@Test
public void testGetIndexedValuesStringIsNotNameOrId() throws Exception {
final NameResolver<ProjectComponent> nameResolver = mockController.getMock(NameResolver.class);
ComponentIndexInfoResolver resolver = new ComponentIndexInfoResolver(nameResolver);
nameResolver.getIdsFromName("abc");
mockController.setReturnValue(Collections.emptyList());
mockController.replay();
final List<String> result = resolver.getIndexedValues("abc");
assertEquals(0, result.size());
mockController.verify();
}
@Test
public void testGetIndexedValuesLongExists() throws Exception {
final NameResolver<ProjectComponent> nameResolver = mockController.getMock(NameResolver.class);
ComponentIndexInfoResolver resolver = new ComponentIndexInfoResolver(nameResolver);
nameResolver.idExists(2L);
mockController.setReturnValue(true);
mockController.replay();
final List<String> result = resolver.getIndexedValues(2L);
assertEquals(1, result.size());
assertTrue(result.contains("2"));
mockController.verify();
}
@Test
public void testGetIndexedValuesLongIdIsNameDoesntExist() throws Exception {
final NameResolver<ProjectComponent> nameResolver = mockController.getMock(NameResolver.class);
ComponentIndexInfoResolver resolver = new ComponentIndexInfoResolver(nameResolver);
nameResolver.idExists(100L);
mockController.setReturnValue(false);
nameResolver.getIdsFromName("100");
mockController.setReturnValue(Collections.emptyList());
mockController.replay();
final List<String> result = resolver.getIndexedValues(100L);
assertTrue(result.isEmpty());
mockController.verify();
}
@Test
public void testGetIndexedValuesStringHappyPath() throws Exception {
final MockComponent mockComponent1 = new MockComponent(1L, "component1");
final MockComponent mockComponent2 = new MockComponent(2L, "component1");
final NameResolver<ProjectComponent> nameResolver = mockController.getMock(NameResolver.class);
nameResolver.getIdsFromName("component1");
mockController.setReturnValue(CollectionBuilder.newBuilder("1", "2").asList());
mockController.replay();
ComponentIndexInfoResolver resolver = new ComponentIndexInfoResolver(nameResolver);
final List<String> result = resolver.getIndexedValues("component1");
assertEquals(2, result.size());
assertTrue(result.contains(mockComponent1.getId().toString()));
assertTrue(result.contains(mockComponent2.getId().toString()));
mockController.verify();
}
/**
* NameServer and NameClient test.
*
* @throws Exception
*/
@Test
public void testNameClient() throws Exception {
LOG.log(Level.FINEST, this.name.getMethodName());
final String localAddress = localAddressProvider.getLocalAddress();
final Injector injector = Tang.Factory.getTang().newInjector();
injector.bindVolatileParameter(
NameServerParameters.NameServerIdentifierFactory.class, this.factory);
injector.bindVolatileInstance(LocalAddressProvider.class, this.localAddressProvider);
try (final NameServer server = injector.getInstance(NameServer.class)) {
this.port = server.getPort();
final Map<Identifier, InetSocketAddress> idToAddrMap =
new HashMap<Identifier, InetSocketAddress>();
idToAddrMap.put(
this.factory.getNewInstance("task1"), new InetSocketAddress(localAddress, 7001));
idToAddrMap.put(
this.factory.getNewInstance("task2"), new InetSocketAddress(localAddress, 7002));
// registration
// invoke registration from the client side
Configuration nameResolverConf =
NameResolverConfiguration.CONF
.set(NameResolverConfiguration.NAME_SERVER_HOSTNAME, localAddress)
.set(NameResolverConfiguration.NAME_SERVICE_PORT, this.port)
.set(NameResolverConfiguration.CACHE_TIMEOUT, this.TTL)
.set(NameResolverConfiguration.RETRY_TIMEOUT, RETRY_TIMEOUT)
.set(NameResolverConfiguration.RETRY_COUNT, RETRY_COUNT)
.build();
try (final NameResolver client =
Tang.Factory.getTang().newInjector(nameResolverConf).getInstance(NameClient.class)) {
for (final Identifier id : idToAddrMap.keySet()) {
client.register(id, idToAddrMap.get(id));
}
// wait
final Set<Identifier> ids = idToAddrMap.keySet();
busyWait(server, ids.size(), ids);
// lookup
final Identifier id1 = this.factory.getNewInstance("task1");
final Identifier id2 = this.factory.getNewInstance("task2");
final Map<Identifier, InetSocketAddress> respMap =
new HashMap<Identifier, InetSocketAddress>();
InetSocketAddress addr1 = client.lookup(id1);
respMap.put(id1, addr1);
InetSocketAddress addr2 = client.lookup(id2);
respMap.put(id2, addr2);
for (final Identifier id : respMap.keySet()) {
LOG.log(Level.FINEST, "Mapping: {0} -> {1}", new Object[] {id, respMap.get(id)});
}
Assert.assertTrue(isEqual(idToAddrMap, respMap));
// un-registration
for (final Identifier id : idToAddrMap.keySet()) {
client.unregister(id);
}
// wait
busyWait(server, 0, ids);
final Map<Identifier, InetSocketAddress> serverMap =
new HashMap<Identifier, InetSocketAddress>();
addr1 = server.lookup(id1);
if (addr1 != null) {
serverMap.put(id1, addr1);
}
addr2 = server.lookup(id1);
if (addr2 != null) {
serverMap.put(id2, addr2);
}
Assert.assertEquals(0, serverMap.size());
}
}
}
