matches = matches || EvaluateListenerFilterPredicates(r, port)
		}
		return matches
	case *listener.ListenerFilterChainMatchPredicate_DestinationPortRange:
		return int32(port) >= r.DestinationPortRange.GetStart() && int32(port) < r.DestinationPortRange.GetEnd()
	default:
		panic("unsupported predicate")
	}

    public Object[] toArray() {
        return parent.toArray();
    }

    @Override
    public <T> T[] toArray(final T[] a) {
        return parent.toArray(a);
    }

    public int getStart() {
        return start;
    }

    public int getOffset() {
        return offset;
    }

    public int getPageSize() {
        return pageSize;
    }

        given:
        def a = profile.getDependencySetProfile("a").setStart(100).setFinish(200)
        def b = profile.getDependencySetProfile("b").setStart(200).setFinish(400)
        def c = profile.getDependencySetProfile("c").setStart(400).setFinish(600)
        def d = profile.getDependencySetProfile("d").setStart(600).setFinish(601)

        expect:
        profile.dependencySets.operations == [b, c, a, d]

        def a = profile.getTaskProfile("foo:a").completed(Stub(TaskState)).setStart(100).setFinish(300)
        def b = profile.getTaskProfile("foo:b").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def c = profile.getTaskProfile("foo:c").completed(Stub(TaskState)).setStart(300).setFinish(300)
        def d = profile.getTaskProfile("foo:d").completed(Stub(TaskState)).setStart(301).setFinish(302)

        expect:

    // ProjectEvaluationListener
    @Override
    public void beforeEvaluate(Project project) {
        long now = clock.getCurrentTime();
        buildProfile.getProjectProfile(project.getPath()).getConfigurationOperation().setStart(now);
    }

    @Override
    public void afterEvaluate(Project project, ProjectState state) {
        long now = clock.getCurrentTime();

        model.getProjectProfile("a").getTaskProfile("a:foo").completed(Stub(TaskState)).setStart(time(12, 25, 0)).setFinish(time(12, 26, 30))
        model.getProjectProfile("a").getTaskProfile("a:bar").completed(Stub(TaskState)).setStart(time(12, 26, 30)).setFinish(time(12, 27, 0))

        model.getProjectProfile("b").configurationOperation.start = time(12, 20, 10)

import (
	"os"
	"testing"

	"github.com/fsnotify/fsnotify"
	"github.com/stretchr/testify/assert"
)

func TestGetStat(t *testing.T) {
	event := fsnotify.Event{Name: "name", Op: fsnotify.Create}
	fi, err := getStat(event)
	fiExpected, errExpected := os.Stat(event.Name)

	assert.Equal(t, fi, fiExpected)
	assert.Equal(t, err, errExpected)
}

func TestGetSocketPath(t *testing.T) {
	socketPath := "/tmp/foo/lish.sock"

    public String getDescription() {
        return description;
    }

    public ContinuousOperation start(long start) {
        ContinuousOperation child = new ContinuousOperation("<child>");
        child.setStart(start);
        children.add(child);
        return child;
    }

        this.description = description;
    }

    @Override
    public String toString() {
        return description;
    }

    public ContinuousOperation setStart(long start) {
        this.start = start;
        return this;
    }

    public ContinuousOperation setFinish(long finish) {
        this.finish = finish;
        return this;
    }

See the License for the specific language governing permissions and
limitations under the License.
*/

package pluginwatcher

import (
	"os"

	"github.com/fsnotify/fsnotify"
)

func getStat(event fsnotify.Event) (os.FileInfo, error) {
	return os.Stat(event.Name)
}

func getSocketPath(socketPath string) string {
	return socketPath