// Copyright 2013 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 state2

import "./state"

                    assert !state2.hasMutableState()
                    state1.forceAccessToMutableState {
                        assertTrue state1.hasMutableState()
                        assertTrue !state2.hasMutableState()
                    }
                    state1.applyToMutableState {
                        assertTrue state1.hasMutableState()
                        assertTrue !state2.hasMutableState()
                    }

becomes

	{
		var #next int
		var #state1 = abi.RF_READY
		f(func() { // 1,2
			if #state1 != abi.RF_READY { runtime.panicrangestate(#state1) }
			#state1 = abi.RF_PANIC
			var #state2 = abi.RF_READY
			g(func() { // 3,4
				if #state2 != abi.RF_READY { runtime.panicrangestate(#state2) }
				#state2 = abi.RF_PANIC
				var #state3 = abi.RF_READY
				h(func() { // 5,6

    def state1 = Mock(ChangeContainer)
    def state2 = Mock(ChangeContainer)
    def state = new SummarizingChangeContainer(state1, state2)
    def visitor = new CollectingChangeVisitor()

    def "looks for changes in all delegate change sets"() {
        when:
        state.accept(visitor)

        then:
        1 * state1.accept(_) >> true
        1 * state2.accept(_) >> true
        0 * _

        !bean.isImmutable()
        def state = bean.unpackState()
        state.length == 1
        state[0] == null

        def copy = managedFactoryRegistry.lookup(bean.getFactoryId()).fromState(BeanWithAbstractProperty, state)
        !copy.is(bean)
        copy.name == null

        bean.setName("name")
        copy.name == null

        def state2 = bean.unpackState()
        state2.length == 1
        state2[0] == "name"

		if err != nil {
			return 0, 0, err
		}

		state1, err := rbr.val(uint8(fseBits))
		if err != nil {
			return 0, 0, err
		}

		state2, err := rbr.val(uint8(fseBits))
		if err != nil {
			return 0, 0, err
		}

		// There are two independent FSE streams, tracked by
		// state1 and state2. We decode them alternately.

		for {
			pt := &fseTable[state1]
			if !rbr.fetch(pt.bits) {
				if count >= 254 {

        def impl2 = proxyClass.newInstance(state2, typeConverter)

        then:
        Matchers.strictlyEquals(impl1, sameState)
        Matchers.strictlyEquals(impl1, sameStateDifferentType)
        !impl1.equals(impl2)
    }

    def "Two views are equal when their state objects are equal"() {
        def state1 = Mock(GeneratedViewState)
        def state2 = Mock(GeneratedViewState)

        when:
        gradle.attachSettings(state2)

        then:
        1 * state1.close()
    }

    def "closes settings when discarded"() {
        def state = Mock(SettingsState)

        given:
        gradle.attachSettings(state)

        when:
        gradle.resetState()

        then:
        1 * state.close()
    }

    }

    def "can unpack state and recreate instance"() {
        given:
        def property = propertyWithNoValue()

        expect:
        property instanceof Managed
        !property.isImmutable()
        def state = property.unpackState()
        def copy = managedFactory().fromState(property.publicType(), state)
        !copy.is(property)
        !copy.present

func state1(s *scanner, c byte) int {
	if '0' <= c && c <= '9' {
		s.step = state1
		return scanContinue
	}
	return state0(s, c)
}

// state0 is the state after reading `0` during a number.
func state0(s *scanner, c byte) int {
	if c == '.' {
		s.step = stateDot
		return scanContinue
	}
	if c == 'e' || c == 'E' {
		s.step = stateE
		return scanContinue
	}