// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fmt

var IsSpace = isSpace

// too large to be used as a formatting width or precision.
func tooLarge(x int) bool {
	const max int = 1e6
	return x > max || x < -max
}

// parsenum converts ASCII to integer.  num is 0 (and isnum is false) if no number present.
func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
	if start >= end {
		return 0, false, end
	}

	arg += s.firstArg - 1 // We want to zero-index the actual arguments.
	s.argNum = arg
	s.hasIndex = true
	s.indexPending = true
	return true
}

// parseNum scans a width or precision (or *). It returns false if there's a bad index expression.
func (s *formatState) parseNum() bool {
	if s.nbytes < len(s.format) && s.format[s.nbytes] == '*' {
		if s.indexPending { // Absorb it.
			s.indexPending = false
		}
		s.nbytes++

		{"12a3", 0, 4, 12, true, 2},
		{"1234", 0, 4, 1234, true, 4},
		{"1a234", 1, 3, 0, false, 1},
	}
	for _, tt := range testCases {
		num, isnum, newi := Parsenum(tt.s, tt.start, tt.end)
		if num != tt.num || isnum != tt.isnum || newi != tt.newi {
			t.Errorf("parsenum(%q, %d, %d) = %d, %v, %d, want %d, %v, %d", tt.s, tt.start, tt.end, num, isnum, newi, tt.num, tt.isnum, tt.newi)
		}
	}
}

			}
			// Otherwise at EOF; "too many operands" error handled below
			break
		}
		i++ // % is one byte

		// do we have 20 (width)?
		var widPresent bool
		s.maxWid, widPresent, i = parsenum(format, i, end)
		if !widPresent {
			s.maxWid = hugeWid
		}

		c, w := utf8.DecodeRuneInString(format[i:])
		i += w

		if c != 'c' {
			s.SkipSpace()
		}
		if c == '%' {

<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:

                <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)

                <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
    }

        }
        samples
    }

    MutableModuleComponentResolveMetadata parse(File file) {
        switch (file.parentFile.name) {
            case 'pom':
                return removeSources(parsePom(file))
            case 'ivy':
                return removeSources(parseIvy(file))
            case 'gradle':
                return removeSources(parseGradle(file))
        }

    TestFile pomFile
    MutableMavenModuleResolveMetadata metadata

    def "setup"() {
        pomFile = tmpDir.file('test-pom.xml')
    }

    protected void parsePom() {
        metadata = parseMetaData()
    }

    protected LocallyAvailableExternalResource asResource(File file) {
        return fileRepository.resource(file)
    }