func getTimeRange(logStr string, start, end time.Time) string {
	var sb strings.Builder
	write := false
	for _, l := range strings.Split(logStr, "\n") {
		t, _, _, valid := parseLog(l)
		if valid {
			write = false
			if (t.Equal(start) || t.After(start)) && (t.Equal(end) || t.Before(end)) {
				write = true
			}
		}
		if write {
			sb.WriteString(l)
			sb.WriteString("\n")
		}

Emmanuel Odeke <******@****.***> 1460323946 -0700

	i := 0
	for _, l := range gotLogs {
		var parsedLog map[string]any
		assert.NoError(t, json.Unmarshal([]byte(l), &parsedLog))
		if parsedLog["scope"] != "cni-plugin" {
			// Each log is 2x: one direct, and one over UDS. Just test the UDS one
			continue
		}
		// remove scope since it is constant and not needed to test
		delete(parsedLog, "scope")
		// check time is there
		if _, f := parsedLog["time"]; !f {

                <artifactId>module-b</artifactId>
                <version>1.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>
"""

        when:
        parsePom()

        then:
        def dep = single(metadata.dependencies)
        dep.selector == moduleId('group-b', 'module-b', '1.0')
        dep.scope == MavenScope.Compile
        hasDefaultDependencyArtifact(dep)

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>group-one</groupId>
    <artifactId>artifact-one</artifactId>
    <version>my-version-20141012.121000-1</version>
</project>
"""

        when:
        parsePom()

        then:
        metadata.id == componentId('group-one', 'artifact-one', 'my-version-SNAPSHOT')
    }

    def "Retrieves variables from parent"() {
        given:

                <some.version>version-one</some.version>
            </properties>
        </profile>
    </profiles>
</project>
"""

        when:
        parsePom()

        then:
        metadata.id == componentId('group-one', 'artifact-one', 'version-one')
        metadata.dependencies.empty
    }

            }
            return Long.parseLong(normalized);
        } catch (NumberFormatException ex) {
            throw new IllegalArgumentException("Cannot parse memory amount notation: " + notation, ex);
        }
    }

    private static long parseWithFactor(String notation, long factor) {
        return Long.parseLong(notation.substring(0, notation.length() - 1)) * factor;
    }

        long memUsage;
        long memTotal;
        long memAvailable;

        try {
            memUsage = Long.parseLong(memUsageString);
            memTotal = Long.parseLong(memTotalString);
            memAvailable = Math.max(0, memTotal - memUsage);
        } catch (NumberFormatException e) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package json

import (
	"testing"
)

func TestTagParsing(t *testing.T) {
	name, opts := parseTag("field,foobar,foo")
	if name != "field" {
		t.Fatalf("name = %q, want field", name)
	}
	for _, tt := range []struct {
		opt  string
		want bool
	}{
		{"foobar", true},
		{"foo", true},
		{"bar", false},

        } else if (o instanceof String) {
            return toPrimitiveLong((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {
                return Long.parseLong(new SimpleDateFormat(pattern).format(o));
            }
            return ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? 1 : 0;
        } else {