spec.setArgs("--command", String.join("\n", script));
                    spec.setProgressHandler(progressHandler);
                });
            } catch (Exception e) {
                /*getLogger().error("Failed command, dumping dmesg", e);
                service.execute(spec -> {
                    spec.setCommand("ssh");
                    spec.setArgs("--command", "dmesg");

		}
		s := endpointSet{
			endpoints:  args,
			setIndexes: setIndexes,
		}
		setArgs = s.Get()
	} else {
		s, err := parseEndpointSet(setDriveCount, args...)
		if err != nil {
			return nil, err
		}
		setArgs = s.Get()
	}

	uniqueArgs := set.NewStringSet()
	for _, sargs := range setArgs {
		for _, arg := range sargs {
			if uniqueArgs.Contains(arg) {

        assertEquals(elevateWord3.getReadings().get(0), settings.elevateWord().get()[2].getReadings().get(0));
        assertEquals(elevateWord3.getTags().get(0), settings.elevateWord().get()[2].getTags().get(0));
        assertEquals(elevateWord3.getRoles().get(0), settings.elevateWord().get()[2].getRoles().get(0));
    }

    @Test
    public void test_delete() {

        assertArrayEquals(readings, item.getReadings());
        assertNotNull(item.getFields());
        assertEquals(0, item.getFields().length);
        assertNotNull(item.getTags());
        assertEquals(0, item.getTags().length);
        assertNotNull(item.getRoles());
        assertEquals(1, item.getRoles().length); // Default role is added
        assertNotNull(item.getLanguages());

        workerExecutor.noIsolation().submit(DockerBuildAction.class, params -> {
            params.getDockerContext().set(dockerContext);
            params.getMarkerFile().set(markerFile);
            params.getTags().set(Arrays.asList(tags));
            params.getPull().set(pull);
            params.getNoCache().set(noCache);
            params.getBaseImages().set(Arrays.asList(baseImages));

        assertTrue(items.size() > 0);
        SuggestItem item = items.get(0);
        assertTrue("Should have multiple tags", item.getTags().length >= 2);
    }

    @Test
    public void test_parseQueryLog_withMultipleRoles() throws Exception {
        QueryLog queryLog = new QueryLog("content:test AND role:admin AND role:user", null);

        boolean destroyVM = Util.getBooleanProperty("vagrant.destroy", true);
        if (destroyVM) {
            execute(spec -> {
                spec.setCommand("destroy");
                spec.setArgs("--force");
            });
        }

        // register box to be shutdown if gradle dies
        reaper = reaperServiceProvider.get();

            map.put(FieldNames.READING_PREFIX + i, values);
        }

        map.put(FieldNames.FIELDS, item.getFields());
        map.put(FieldNames.TAGS, item.getTags());
        map.put(FieldNames.ROLES, item.getRoles());
        map.put(FieldNames.LANGUAGES, item.getLanguages());
        map.put(FieldNames.KINDS, Stream.of(item.getKinds()).map(SuggestItem.Kind::toString).toArray());

            builder.getMainModule().set("jdk.httpserver");
            builder.setStandardOutput(System.out);
            builder.setErrorOutput(System.err);
            builder.setArgs(Arrays.asList("-p", getPort().get(), "-d", getDocsDirectory().get().getAsFile().getAbsolutePath()));
            registry.start(getPath(), DeploymentRegistry.ChangeBehavior.RESTART, JavaApplicationHandle.class, builder);
        }

			updated = true
			break
		}
	}
	if !updated {
		// Append to the end of tags list
		r.tags = append(r.tags, KeyVal{key, val})
	}
	return r
}

// GetTags - returns the user defined tags
func (r *ReqInfo) GetTags() []KeyVal {
	if r == nil {
		return nil
	}
	r.RLock()
	defer r.RUnlock()
	return append(make([]KeyVal, 0, len(r.tags)), r.tags...)
}