classContent.childNodes.each { Node n ->
            classSection << n
        }

        propertiesTable = getTable('Properties')
        propertiesSection = propertiesTable.parentNode
        methodsTable = getTable('Methods')
        methodsSection = methodsTable.parentNode
    }

    String getId() { return id }

    String getName() { return className }

        set.addDependency(dep2)

        then:
        set.getState(node) == Node.DependenciesState.NOT_COMPLETE

        when:
        set.onNodeComplete(node, dep1)

        then:
        set.getState(node) == Node.DependenciesState.NOT_COMPLETE

        when:
        set.onNodeComplete(node, dep2)

        then:
        set.getState(node) == Node.DependenciesState.COMPLETE_AND_SUCCESSFUL
    }

            return false;
        }

        Span rhs = (Span) obj;
        return Objects.equal(getStyle(), rhs.getStyle())
            && Objects.equal(getText(), rhs.getText());
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(getStyle(), getText());
    }

        public StyledTextOutput append(char c) {
            Style original = textOutput.getStyle();
            textOutput.style(style).append(c).style(original);
            return this;
        }

        @Override
        public StyledTextOutput append(CharSequence csq) {
            Style original = textOutput.getStyle();
            textOutput.style(style).append(csq).style(original);
            return this;

            resourceFilterState = resourceFilter.getState();
            manifestAttributesFilterState = manifestAttributesFilter.getState();
            propertiesFileFiltersState = propertiesFileFilters.getState();
        }

        boolean isTrivial() {

  double scale_product = in_spec.getScale() * w_spec.getScale();
  if (fabs(scale_product - b_spec.getScale()) >= 1e-6) return failure();

  // input multipliers
  input_multipliers->append(3, kUnitQuantizedMultiplier);

  // output multipliers
  double real_multiplier = scale_product / o_spec.getScale();
  output_multipliers->push_back(QuantizeMultiplier(real_multiplier));

                if (node.isAtLeast(predicate.getState())) {
                    throw new IllegalStateException(String.format("Cannot add rule %s for model element '%s' at state %s as this element is already at state %s.",
                        modelBinding.referrer,
                        node.getPath(),
                        predicate.getState().previous(),
                        node.getState()
                    ));
                }

    }

    @Nullable
    public ModelPath getScope() {
        return reference.getScope();
    }

    public ModelNode.State getState() {
        return reference.getState();
    }

	return false
}

func makeRaw(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func getState(fd int) (*State, error) {
	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
}

func restore(fd int, state *State) error {

// restored.
func MakeRaw(fd int) (*State, error) {
	return makeRaw(fd)
}

// GetState returns the current state of a terminal which may be useful to
// restore the terminal after a signal.
func GetState(fd int) (*State, error) {
	return getState(fd)
}

// Restore restores the terminal connected to the given file descriptor to a
// previous state.