From be12211b79e50a3a3dc8fee784c4228059bf9a2c Mon Sep 17 00:00:00 2001 From: xpetit <32063953+xpetit@users.noreply.github.com> Date: Sun, 4 Apr 2021 20:01:33 +0200 Subject: [PATCH] Externalize RC (github.com/01-edu/rc) --- go/tests/Dockerfile | 4 +- go/tests/go.mod | 7 +- go/tests/go.sum | 6 - go/tests/rc/README.md | 139 --- go/tests/rc/rc.go | 892 ------------------ go/tests/rc/rc_test.go | 151 --- go/tests/rc/tests/abc/main.go | 10 - go/tests/rc/tests/doopprog/main.go | 214 ----- go/tests/rc/tests/eightqueens.go | 86 -- go/tests/rc/tests/empty/empty | 0 go/tests/rc/tests/empty/empty.go | 0 go/tests/rc/tests/example.go | 25 - .../tests/grand-prix-go-burdeux/isnegative.go | 11 - go/tests/rc/tests/moreThanOnePackage/func.go | 5 - go/tests/rc/tests/moreThanOnePackage/main.go | 7 - go/tests/rc/tests/nesting/main.go | 16 - .../rc/tests/printalphabet/printalphabet.go | 29 - .../rc/tests/testLiteralRestriction/main.go | 10 - go/tests/rc/tests/testingRepetitions/main.go | 19 - go/tests/rc/tests/testingSimpleFunc.go | 11 - go/tests/rc/tests/testingWrapping.go | 12 - go/tests/rc/tests/util/util.go | 23 - go/tests/rc/tests/utilDepth2/wrapper.go | 5 - 23 files changed, 3 insertions(+), 1679 deletions(-) delete mode 100644 go/tests/rc/README.md delete mode 100644 go/tests/rc/rc.go delete mode 100644 go/tests/rc/rc_test.go delete mode 100644 go/tests/rc/tests/abc/main.go delete mode 100644 go/tests/rc/tests/doopprog/main.go delete mode 100644 go/tests/rc/tests/eightqueens.go delete mode 100644 go/tests/rc/tests/empty/empty delete mode 100644 go/tests/rc/tests/empty/empty.go delete mode 100644 go/tests/rc/tests/example.go delete mode 100644 go/tests/rc/tests/grand-prix-go-burdeux/isnegative.go delete mode 100644 go/tests/rc/tests/moreThanOnePackage/func.go delete mode 100644 go/tests/rc/tests/moreThanOnePackage/main.go delete mode 100644 go/tests/rc/tests/nesting/main.go delete mode 100644 go/tests/rc/tests/printalphabet/printalphabet.go delete mode 100644 go/tests/rc/tests/testLiteralRestriction/main.go delete mode 100644 go/tests/rc/tests/testingRepetitions/main.go delete mode 100644 go/tests/rc/tests/testingSimpleFunc.go delete mode 100644 go/tests/rc/tests/testingWrapping.go delete mode 100644 go/tests/rc/tests/util/util.go delete mode 100644 go/tests/rc/tests/utilDepth2/wrapper.go diff --git a/go/tests/Dockerfile b/go/tests/Dockerfile index 53ca2d4ff..6d1fd0a90 100644 --- a/go/tests/Dockerfile +++ b/go/tests/Dockerfile @@ -15,8 +15,8 @@ COPY base base COPY func func COPY lib lib COPY prog prog -COPY rc rc -RUN go install ./rc ./prog/... +RUN go get github.com/01-edu/rc +RUN go install ./prog/... RUN rm -rf /piscine-go COPY entrypoint.sh /usr/local/bin diff --git a/go/tests/go.mod b/go/tests/go.mod index 014c9ed42..02e6e12b6 100644 --- a/go/tests/go.mod +++ b/go/tests/go.mod @@ -2,11 +2,6 @@ module github.com/01-edu/public/go/tests go 1.16 -require ( - github.com/01-edu/z01 v0.1.0 - github.com/mattn/go-runewidth v0.0.10 // indirect - github.com/tatsushid/go-prettytable v0.0.0-20141013043238-ed2d14c29939 - student v0.0.0 -) +require student v0.0.0 replace student => ../../../piscine-go diff --git a/go/tests/go.sum b/go/tests/go.sum index 4f1e49b6e..5789f5c36 100644 --- a/go/tests/go.sum +++ b/go/tests/go.sum @@ -1,8 +1,2 @@ github.com/01-edu/z01 v0.1.0 h1:Rr1p92CKYXUgVFw872iGDABXpdkuKf2jmS+KV6r1034= github.com/01-edu/z01 v0.1.0/go.mod h1:BH7t35JaNFuP83rTJDc5nkSfgmC/HYVcJsUcdFqYZNo= -github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg= -github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= -github.com/rivo/uniseg v0.1.0 h1:+2KBaVoUmb9XzDsrx/Ct0W/EYOSFf/nWTauy++DprtY= -github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/tatsushid/go-prettytable v0.0.0-20141013043238-ed2d14c29939 h1:BhIUXV2ySTLrKgh/Hnts+QTQlIbWtomXt3LMdzME0A0= -github.com/tatsushid/go-prettytable v0.0.0-20141013043238-ed2d14c29939/go.mod h1:omGxs4/6hNjxPKUTjmaNkPzehSnNJOJN6pMEbrlYIT4= diff --git a/go/tests/rc/README.md b/go/tests/rc/README.md deleted file mode 100644 index a5c794207..000000000 --- a/go/tests/rc/README.md +++ /dev/null @@ -1,139 +0,0 @@ -### RC (Restrictions Checker) - -This program analyzes a go source file and displays in standard output the imports, functions, slice types and loops used without authorization. - -### By default: - -- Allowed - - - All functions declared inside the source file are allowed - - Slices of all types are allowed - - Loops are allowed - - Relative imports are allowed - -- Disallowed - - - NO absolute imports are allowed - - NO built-in functions are allowed. - - NO casting is allowed - -### Flags - -- `-h` for help -- `-cast` allows casting to every built-in type. -- `-no-for` prohibits the use of `for` loops in the program or function. -- `-allow-builtin` allows all builtin functions and casting to builtin types -- `-no-slices` disallows the use of all slices types -- `-no-these-slices=type1,type2`: disallows the slices of type1 and type2 -- `-no-relative-imports`: disallows the use of relative imports -- `--no-lit="{PATTERN}"`: disallows character and string literals that match the pattern `PATTERN` which represent a Regular Expression - -### Arguments: - -- Flags can be passed at any point (in the beginning, middle or end) of the argument list - -- The remaining arguments represent the allowed functions - - Allowed imports and functions from a package - - `.*` for full imports (all functions from that package are allowed) - - ``.`` for partial imports (only the function is allowed) - - ``.`#amount` the function is only allowed to be used `amount` number of times - - Ex: `fmt.*` (all functions from `fmt` are allowed), `github.com/01-edu/z01.PrintRune` (only `z01.PrintRune` is allowed), `fmt.Println#2` (fmt.Println can only be used 2 times or less) - - Allowed built-in functions - - Use the name of the built-in function - - It is possible to limit the number of calls of a functions like with the imports using the '#' character - - Ex: `make`, `append`, `len`, `print#2`. - -### Example: - -- To allow the import of the whole `fmt` package, `z01.PrintRune` and the built-in functions `len` for the file `main.go` - Note: The imports must be written exactly the way they are written inside the source code, example: - - ```console - _$ rc main.go fmt.* github.com/01-edu/z01.PrintRune len - ``` - -- Import "fmt" is allowed by executing - - ```console - _$ rc sourcefile.go fmt.* - ``` - -- Import "go/parser" is allowed by executing - - ```console - _$ rc sourcefile.go go/parser.* - ``` - -- Import "github.com/01-edu/z01" is allowed by executing - - ```console - _$ rc sourcefile.go github.com/01-edu/z01.* - ``` - -- Disallow literals - - - Use the flag `--no-lit="{PATTERN}"` - ```console - _$ rc -no-slices --no-lit=[b-yB-Y] main.go fmt.* github.com/01-edu/z01.PrintRune len - ``` - -- Allow all type of casting - - ```console - _$ rc -cast sourcefile.go fmt.* github.com/01-edu/z01 os.* strconv.* make len append - ``` - - - this will allow all type of casting in the file sourcefile.go - -- Disallow the use of the slices of type `string` and `int` - - ```console - _$ rc -no-these-slices=string,int sourcefile.go - ``` - -- To allow just one type of casting - - ```console - _$ rc sourcefile.go fmt.* github.com/01-edu/z01 os.* strconv.* make len append rune - ``` - - - this will allow the casting to `rune`, but not `int8`, ..., `string`, `float32`, ... - -### How to read the error message - -Let us look to an example snipped of code, let us imagine this code in a file called `main.go`: - -```go -package main - -import "fmt" - -func main() { - for _, v := range "abcdefghijklmnopqrstuvwxyz" { - fmt.Println(v) - } - fmt.Println() -} -``` - -Now let us run the `rc` and understand the message - -```console -_$ rc main.go github.com/01-edu/z01.PrintRune -Parsing: - Ok -Cheating: - TYPE: NAME: LOCATION: - illegal-import fmt main.go:3:8 - illegal-access fmt.Println main.go:7:3 - illegal-access fmt.Println main.go:10:2 - illegal-definition main main.go:5:1 -``` - -The important part is printed after the `Cheating` tag: - -- The import of of the package `fmt` is not allowed -- In go the dot (.) is also known as the access operator for that reason the use of fmt.Println is shown as an illegal-access -- Finally the main function is shown as illegal-definition because the function is using disallowed functions that does not mean that the function can not be defined it just mean that the definition of the function must be changed to not use disallowed functions. -- Notice that the third column of the output with the tag "LOCATION:" show the location in the following way filepath:line:column - This mean that you have to substitute the illegal function for ones that are allowed or write your own function with allowed functions diff --git a/go/tests/rc/rc.go b/go/tests/rc/rc.go deleted file mode 100644 index 6816796f7..000000000 --- a/go/tests/rc/rc.go +++ /dev/null @@ -1,892 +0,0 @@ -package main - -import ( - "flag" - "fmt" - "go/ast" - "go/parser" - "go/token" - "os" - "path/filepath" - "regexp" - "sort" - "strconv" - "strings" - - table "github.com/tatsushid/go-prettytable" -) - -type strBoolMap map[string]bool - -// Implementation of the flag.Value interface -func (a *strBoolMap) String() (res string) { - for k, _ := range *a { - res += k - } - return res -} - -// Implementation of the flag.Value interface -func (a *strBoolMap) Set(str string) error { - if *a == nil { - *a = make(map[string]bool) - } - s := strings.Split(str, ",") - for _, v := range s { - (*a)[v] = true - } - return nil -} - -// Flag that groups a boolean value and a regular expression -type regexpFlag struct { - active bool - reg *regexp.Regexp -} - -// Implementation of the flag.Value interface -func (r *regexpFlag) String() string { - if r.reg != nil { - return r.reg.String() - } - return "" -} - -// Implementation of the flag.Value interface -func (r *regexpFlag) Set(s string) error { - r.active = true - r.reg = regexp.MustCompile(s) - return nil -} - -var ( - allowedFun = make(map[string]map[string]bool) - allowedRep = make(map[string]int) - // Flags - noArrays bool - noSlices bool - noRelativeImports bool - noTheseSlices strBoolMap - casting bool - noFor bool - noLit regexpFlag - allowBuiltin bool -) - -type illegal struct { - T string - Name string - Pos string -} - -func (i *illegal) String() string { - return i.T + " " + i.Name + " " + i.Pos -} - -func init() { - flag.Var(&noTheseSlices, "no-these-slices", "Disallowes the slice types passed in the flag as a comma-separated list without spaces\nLike so: -no-these-slices=int,string,bool") - flag.Var(&noLit, "no-lit", - `The use of basic literals (strings or characters) matching the pattern -no-lit="{PATTERN}" -passed to the program would not be allowed`, - ) - flag.BoolVar(&noRelativeImports, "no-relative-imports", false, `Disallowes the use of relative imports`) - flag.BoolVar(&noFor, "no-for", false, `The "for" instruction is not allowed`) - flag.BoolVar(&casting, "cast", false, "Allowes casting") - flag.BoolVar(&noArrays, "no-array", false, "Deprecated: use -no-slices") - flag.BoolVar(&noSlices, "no-slices", false, "Disallowes all slice types") - flag.BoolVar(&allowBuiltin, "allow-builtin", false, "Allowes all builtin functions and casting") - sort.Sort(sort.StringSlice(os.Args[1:])) -} - -func main() { - flag.Parse() - filename := goFile(flag.Args()) - - if _, err := os.Stat(filename); err != nil { - fmt.Printf("\t%s\n", err) - os.Exit(1) - } - - err := parseArgs(flag.Args()) - - if err != nil { - fmt.Printf("\t%s\n", err) - os.Exit(1) - } - - load := make(loadedSource) - - currentPath := filepath.Dir(filename) - - err = loadProgram(currentPath, load) - - if err != nil { - fmt.Printf("\t%s\n", err) - os.Exit(1) - } - - info := analyzeProgram(filename, currentPath, load) - - if info.illegals != nil { - fmt.Println("Cheating:") - printIllegals(info.illegals) - os.Exit(1) - } -} - -func goFile(args []string) string { - for _, v := range args { - if strings.HasSuffix(v, ".go") { - return v - } - } - return "" -} - -// Returns the smallest block containing the position pos. It can -// return nil if `pos` is not inside any ast.BlockStmt -func smallestBlock(pos token.Pos, blocks []*ast.BlockStmt) (minBlock *ast.BlockStmt) { - var minSize token.Pos - for _, v := range blocks { - if pos > v.Pos() && pos < v.End() { - size := v.End() - v.Pos() - if minBlock == nil || size < minSize { - minBlock = v - minSize = size - } - } - } - return minBlock -} - -// Used to mark an ast.Object as a function parameter -type data struct { - parameter bool -} - -func fillScope(funcDefs []*function, scope *ast.Scope, scopes map[*ast.BlockStmt]*ast.Scope) { - for _, fun := range funcDefs { - scope.Insert(fun.obj) - for _, name := range fun.params { - obj := ast.NewObj(ast.Fun, name) - obj.Data = data{ - parameter: true, - } - scopes[fun.body].Insert(obj) - } - } -} - -// Create the scopes for a BlockStmt contained inside another BlockStmt -func createChildScope( - block *ast.BlockStmt, - l *loadVisitor, scopes map[*ast.BlockStmt]*ast.Scope) { - blocks := l.blocks - // The smalles block containing the beggining of the block - parentBlock := smallestBlock(block.Pos(), blocks) - if scopes[parentBlock] == nil { - createChildScope(parentBlock, l, scopes) - } - scopes[block] = ast.NewScope(scopes[parentBlock]) -} - -// Returns true if `block` is contained inside another ast.BlockStmt -func isContained(block *ast.BlockStmt, blocks []*ast.BlockStmt) bool { - for _, v := range blocks { - if block == v { - continue - } - if block.Pos() > v.Pos() && block.End() < v.End() { - return true - } - } - return false -} - -// Creates all the scopes in the package -func createScopes(l *loadVisitor, pkgScope *ast.Scope) map[*ast.BlockStmt]*ast.Scope { - scopes := make(map[*ast.BlockStmt]*ast.Scope) - if l.blocks == nil { - return nil - } - for _, b := range l.blocks { - if !isContained(b, l.blocks) { - scopes[b] = ast.NewScope(pkgScope) - } - } - for _, b := range l.blocks { - if scopes[b] == nil { - createChildScope(b, l, scopes) - } - } - return scopes -} - -type blockVisitor struct { - funct []*function - // All functions defined in the scope in any - // way: as a funcDecl, GenDecl or AssigmentStmt - oneBlock bool - // Indicates if the visitor already encounter a - // blockStmt -} - -func (b *blockVisitor) Visit(n ast.Node) ast.Visitor { - switch t := n.(type) { - case *ast.BlockStmt: - if b.oneBlock { - return nil - } - return b - case *ast.FuncDecl, *ast.GenDecl, *ast.AssignStmt: - def := extractFunction(t) - if def == nil || def.obj == nil { - return b - } - b.funct = append(b.funct, def) - return nil - default: - return b - } -} - -type loadedSource map[string]*loadVisitor - -// Returns information about the function defined in the block node -func functionsInfo(block ast.Node) []*function { - b := &blockVisitor{} - ast.Walk(b, block) - return b.funct -} - -func (l *loadVisitor) set() { - l.functions = make(map[string]ast.Node) - l.absImports = make(map[string]*element) - l.relImports = make(map[string]*element) - l.objFunc = make(map[*ast.Object]ast.Node) - l.fset = token.NewFileSet() - l.scopes = make(map[*ast.BlockStmt]*ast.Scope) - -} - -func loadProgram(path string, load loadedSource) error { - l := &loadVisitor{} - l.set() - - pkgs, err := parser.ParseDir(l.fset, path, nil, parser.AllErrors) - - if err != nil { - return err - } - - if len(pkgs) > 1 { - packages := []string{} - for pkgName := range pkgs { - packages = append(packages, pkgName) - } - return fmt.Errorf("There should be only one package in this directory: Found packages: %v", packages) - } - - for _, pkg := range pkgs { - ast.Walk(l, pkg) - l.pkgScope = ast.NewScope(nil) - functions := functionsInfo(pkg) - for _, f := range functions { - l.pkgScope.Insert(f.obj) - } - l.scopes = createScopes(l, l.pkgScope) - fillScope(functions, l.pkgScope, l.scopes) - for block, scope := range l.scopes { - functions := functionsInfo(block) - fillScope(functions, scope, l.scopes) - } - load[path] = l - l.files = pkg.Files - } - - for _, relativePath := range l.relImports { - if load[relativePath.name] == nil { - newPath := filepath.Clean(path + "/" + relativePath.name) - err = loadProgram(newPath, load) - if err != nil { - return err - } - } - } - return nil -} - -func smallestScopeContaining(pos token.Pos, path string, load loadedSource) *ast.Scope { - pack := load[path] - sm := smallestBlock(pos, pack.blocks) - if sm == nil { - return pack.pkgScope - } - - return pack.scopes[sm] -} - -func lookupDefinitionObj(el *element, path string, load loadedSource) *ast.Object { - scope := smallestScopeContaining(el.pos, path, load) - for scope != nil { - obj := scope.Lookup(el.name) - if obj != nil { - return obj - } - scope = scope.Outer - } - return nil -} - -type visitor struct { - fset *token.FileSet - uses []*element - selections map[string][]*element - arrays []*occurrence - lits []*occurrence - fors []*occurrence - callRepetition map[string]int - oneTime bool -} - -func (v *visitor) getPos(n ast.Node) string { - return v.fset.Position(n.Pos()).String() -} - -func (v *visitor) Visit(n ast.Node) ast.Visitor { - switch t := n.(type) { - case *ast.FuncDecl, *ast.GenDecl, *ast.AssignStmt: - //Avoids analyzing a nested declarations - //Since this is handle by the functions `isAllowed` - fdef := extractFunction(t) - if fdef == nil || fdef.obj == nil { - return v - } - if v.oneTime { - return nil - } - v.oneTime = true - return v - case *ast.BasicLit: - if t.Kind != token.CHAR && t.Kind != token.STRING { - return nil - } - v.lits = append(v.lits, &occurrence{pos: v.getPos(n), name: t.Value}) - - case *ast.ArrayType: - if op, ok := t.Elt.(*ast.Ident); ok { - v.arrays = append(v.arrays, &occurrence{ - name: op.Name, - pos: v.getPos(n), - }) - } - case *ast.ForStmt: - v.fors = append(v.fors, &occurrence{ - name: "for", - pos: v.getPos(n), - }) - case *ast.CallExpr: - if fun, ok := t.Fun.(*ast.Ident); ok { - v.uses = append(v.uses, &element{ - name: fun.Name, - pos: fun.Pos(), - }) - v.callRepetition[fun.Name]++ - } - - case *ast.SelectorExpr: - if x, ok := t.X.(*ast.Ident); ok { - v.selections[x.Name] = append(v.selections[x.Name], &element{ - name: t.Sel.Name, - pos: n.Pos(), - }) - v.callRepetition[x.Name+"."+t.Sel.Name]++ - } - } - return v -} - -func (v *visitor) set(fset *token.FileSet) { - v.selections = make(map[string][]*element) - v.callRepetition = make(map[string]int) - v.fset = fset -} - -func (info *info) add(v *visitor) { - info.fors = append(info.fors, v.fors...) - info.lits = append(info.lits, v.lits...) - info.arrays = append(info.arrays, v.arrays...) - for name, v := range v.callRepetition { - info.callRepetition[name] += v - } -} - -// Returns the info structure with all the ocurrences of the element -// of the analised in the project -// TODO: Refactor so this function has only one responsibility -func isAllowed(function *element, path string, load loadedSource, walked map[ast.Node]bool, info *info) bool { - functionObj := lookupDefinitionObj(function, path, load) - definedLocally := functionObj != nil - explicitlyAllowed := allowedFun["builtin"]["*"] || allowedFun["builtin"][function.name] - - isFunctionParameter := func(function *ast.Object) bool { - arg, ok := function.Data.(data) - return ok && arg.parameter - } - - DoesntCallMoreFunctions := func(functionDefinition ast.Node, v *visitor) bool { - if !walked[functionDefinition] { - ast.Walk(v, functionDefinition) - info.add(v) - walked[functionDefinition] = true - } - - return v.uses == nil && v.selections == nil - } - - appendIllegalCall := func(function *element) { - info.illegals = append(info.illegals, &illegal{ - T: "illegal-call", - Name: function.name, - Pos: load[path].fset.Position(function.pos).String(), - }) - - } - if !definedLocally && !explicitlyAllowed { - appendIllegalCall(function) - return false - } - - functionDefinition := load[path].objFunc[functionObj] - v := &visitor{} - v.set(load[path].fset) - - if explicitlyAllowed || isFunctionParameter(functionObj) || - DoesntCallMoreFunctions(functionDefinition, v) { - return true - } - - allowed := true - for _, functionCall := range v.uses { - if !isAllowed(functionCall, path, load, walked, info) { - appendIllegalCall(functionCall) - allowed = false - } - } - - for pck, funcNames := range v.selections { - pathToFunction := func() string { return load[path].relImports[pck].name } - isRelativeImport := load[path].relImports[pck] != nil - for _, fun := range funcNames { - appendIllegalAccess := func() { - info.illegals = append(info.illegals, &illegal{ - T: "illegal-access", - Name: pck + "." + fun.name, - Pos: load[path].fset.Position(fun.pos).String(), - }) - allowed = false - } - - absoluteImport := load[path].absImports[pck] - importExplicitlyAllowed := absoluteImport == nil || - allowedFun[absoluteImport.name][fun.name] || - allowedFun[absoluteImport.name]["*"] - - if !isRelativeImport && !importExplicitlyAllowed { - appendIllegalAccess() - } else if isRelativeImport && - !isAllowed(newElement(fun.name), filepath.Clean(path+"/"+pathToFunction()), load, walked, info) { - appendIllegalAccess() - } - } - } - - if !allowed { - info.illegals = append(info.illegals, &illegal{ - T: "illegal-definition", - Name: functionObj.Name, - Pos: load[path].fset.Position(functionDefinition.Pos()).String(), - }) - } - return allowed -} - -func removeRepetitions(slc []*illegal) (result []*illegal) { - in := make(map[string]bool) - for _, v := range slc { - if in[v.Pos] { - continue - } - result = append(result, v) - in[v.Pos] = true - } - return result -} - -type occurrence struct { - name string - pos string -} - -type info struct { - arrays []*occurrence - lits []*occurrence - fors []*occurrence - callRepetition map[string]int - illegals []*illegal // functions, selections that are not allowed -} - -func newElement(name string) *element { - return &element{ - name: name, - pos: token.Pos(0), - } - -} - -func analyzeProgram(filename, path string, load loadedSource) *info { - fset := load[path].fset - file := load[path].files[filename] - functions := functionsInfo(file) - - info := &info{ - callRepetition: make(map[string]int), - } - - info.illegals = append(info.illegals, analyzeImports(file, fset, noRelativeImports)...) - - walked := make(map[ast.Node]bool) - - for _, fun := range functions { - function := newElement(fun.obj.Name) - isAllowed(function, path, load, walked, info) - } - - info.illegals = append(info.illegals, analyzeLoops(info.fors, noFor)...) - info.illegals = append(info.illegals, analyzeArrayTypes(info.arrays, noArrays || noSlices, noTheseSlices)...) - info.illegals = append(info.illegals, analyzeLits(info.lits, noLit)...) - info.illegals = append(info.illegals, analyzeRepetition(info.callRepetition, allowedRep)...) - info.illegals = removeRepetitions(info.illegals) - return info -} - -func parseArgs(toAllow []string) error { - allowBuiltins() - allowCasting() - for _, v := range toAllow { - err := allowFunction(v) - if err != nil { - return err - } - } - return nil -} - -func allowFunction(functionPath string) error { - functionName := functionName(functionPath) - packageName := packageName(functionPath) - // for github.com/01-edu/z01 shortName = z01 - packageShortName := filepath.Base(packageName) - restrictsRepetitions := strings.ContainsRune(functionPath, '#') - if restrictsRepetitions { - allowedReps, err := repetitionsAllowed(functionPath) - if err != nil { - return err - } - allowedRep[packageShortName+"."+functionName] = allowedReps - } - if allowedFun[packageName] == nil { - allowedFun[packageName] = make(map[string]bool) - } - allowedFun[packageName][functionName] = true - return nil -} - -func functionName(functionPath string) string { - segmentedPath := strings.Split(functionPath, ".") - return strings.Split(segmentedPath[len(segmentedPath)-1], "#")[0] -} - -func packageName(functionPath string) string { - segmentedPath := strings.Split(functionPath, ".") - hasNoPackage := len(segmentedPath) < 2 - if hasNoPackage { - return "builtin" - } - return strings.Join(segmentedPath[:len(segmentedPath)-1], ".") -} - -// Assumes that `functionPath` contains `#` -func repetitionsAllowed(functionPath string) (int, error) { - segmentedPath := strings.Split(functionPath, "#") - repetitions := segmentedPath[len(segmentedPath)-1] - allowedReps, err := strconv.Atoi(repetitions) - if err != nil { - return allowedReps, fmt.Errorf("After the '#' there should be an integer" + - " representing the maximum number of allowed occurrences") - } - return allowedReps, nil -} - -func allowBuiltins() { - if allowedFun["builtin"] == nil { - allowedFun["builtin"] = make(map[string]bool) - } - if allowBuiltin { - allowedFun["builtin"]["*"] = true - } -} - -func allowCasting() { - if allowedFun["builtin"] == nil { - allowedFun["builtin"] = make(map[string]bool) - } - - predeclaredTypes := []string{"bool", "byte", "complex64", "complex128", - "error", "float32", "float64", "int", "int8", - "int16", "int32", "int64", "rune", "string", - "uint", "uint8", "uint16", "uint32", "uint64", - "uintptr", - } - - if casting { - for _, v := range predeclaredTypes { - allowedFun["builtin"][v] = true - } - } -} - -func printIllegals(illegals []*illegal) { - tbl, err := table.NewTable([]table.Column{ - {Header: "\tTYPE:"}, - {Header: "NAME:", MinWidth: 7}, - {Header: "LOCATION:"}, - }...) - if err != nil { - panic(err) - } - tbl.Separator = "\t" - for _, v := range illegals { - tbl.AddRow("\t"+v.T, v.Name, v.Pos) - } - tbl.Print() -} - -func analyzeRepetition(callRepetition map[string]int, allowRep map[string]int) (illegals []*illegal) { - for name, rep := range allowedRep { - if callRepetition[name] > rep { - diff := callRepetition[name] - rep - illegals = append(illegals, &illegal{ - T: "illegal-amount", - Name: name + " exeding max repetitions by " + strconv.Itoa(diff), - Pos: "all the project", - }) - } - } - return illegals -} - -func analyzeLits(litOccu []*occurrence, noLit regexpFlag) (illegals []*illegal) { - if noLit.active { - for _, v := range litOccu { - if noLit.reg.Match([]byte(v.name)) { - illegals = append(illegals, &illegal{ - T: "illegal-lit", - Name: v.name, - Pos: v.pos, - }) - } - } - } - return illegals -} - -func analyzeArrayTypes(arrays []*occurrence, noArrays bool, noTheseSlices map[string]bool) (illegals []*illegal) { - for _, v := range arrays { - if noArrays || noTheseSlices[v.name] { - illegals = append(illegals, &illegal{ - T: "illegal-slice", - Name: v.name, - Pos: v.pos, - }) - } - } - return illegals -} - -func analyzeLoops(fors []*occurrence, noFor bool) (illegals []*illegal) { - if noFor { - for _, v := range fors { - illegals = append(illegals, &illegal{ - T: "illegal-loop", - Name: v.name, - Pos: v.pos, - }) - } - } - return illegals - -} - -type importVisitor struct { - imports map[string]*element -} - -func (i *importVisitor) Visit(n ast.Node) ast.Visitor { - if imp, ok := n.(*ast.ImportSpec); ok { - path, _ := strconv.Unquote(imp.Path.Value) - var name string - if imp.Name != nil { - name = imp.Name.Name - } else { - name = filepath.Base(path) - } - el := &element{ - name: path, - pos: n.Pos(), - } - i.imports[name] = el - } - return i -} - -func analyzeImports(file ast.Node, fset *token.FileSet, noRelImp bool) (illegals []*illegal) { - i := &importVisitor{ - imports: make(map[string]*element), - } - ast.Walk(i, file) - for _, path := range i.imports { - isRelativeImport := isRelativeImport(path.name) - if (noRelativeImports && isRelativeImport) || (allowedFun[path.name] == nil && !isRelativeImport) { - illegals = append(illegals, &illegal{ - T: "illegal-import", - Name: path.name, - Pos: fset.Position(path.pos).String(), - }) - } - } - return illegals -} - -type element struct { - name string - pos token.Pos -} - -type loadVisitor struct { - relImports map[string]*element - absImports map[string]*element - functions map[string]ast.Node - fset *token.FileSet - objFunc map[*ast.Object]ast.Node - blocks []*ast.BlockStmt - scopes map[*ast.BlockStmt]*ast.Scope - // nil after the visit - // used to keep the result of the createScope function - pkgScope *ast.Scope - files map[string]*ast.File -} - -func (l *loadVisitor) String() (res string) { - res = "files" - for f, _ := range l.files { - res += f + "," - } - return res -} - -// Returns all the parameter of a function that identify a function -func functionsInTheParameters(params *ast.FieldList) []string { - var funcs []string - for _, param := range params.List { - if _, ok := param.Type.(*ast.FuncType); ok { - for _, name := range param.Names { - funcs = append(funcs, name.Name) - } - } - } - return funcs -} - -type function struct { - obj *ast.Object // the ast.Object that represents a function - params []string - // the name of the parameter that represent - // functions - body *ast.BlockStmt -} - -// Returns information about a node representing a function declaration -func extractFunction(n ast.Node) *function { - function := &function{} - switch t := n.(type) { - case *ast.FuncDecl: - function.obj = t.Name.Obj - function.params = functionsInTheParameters(t.Type.Params) - function.body = t.Body - return function - case *ast.GenDecl: - for _, v := range t.Specs { - if val, ok := v.(*ast.ValueSpec); ok { - for i, value := range val.Values { - if funcLit, ok := value.(*ast.FuncLit); ok { - function.obj = val.Names[i].Obj - function.params = functionsInTheParameters(funcLit.Type.Params) - function.body = funcLit.Body - } - } - } - } - return function - case *ast.AssignStmt: - for i, right := range t.Rhs { - if funcLit, ok := right.(*ast.FuncLit); ok { - if ident, ok := t.Lhs[i].(*ast.Ident); ok { - function.obj = ident.Obj - function.params = functionsInTheParameters(funcLit.Type.Params) - } - } - return function - } - default: - return function - } - return function -} - -func (l *loadVisitor) Visit(n ast.Node) ast.Visitor { - switch t := n.(type) { - case *ast.ImportSpec: - path, _ := strconv.Unquote(t.Path.Value) - var name string - if t.Name != nil { - name = t.Name.Name - } else { - name = filepath.Base(path) - } - el := &element{ - name: path, - pos: n.Pos(), - } - - if isRelativeImport(path) { - l.relImports[name] = el - } else { - l.absImports[name] = el - } - case *ast.FuncDecl, *ast.GenDecl, *ast.AssignStmt: - fdef := extractFunction(t) - if fdef == nil || fdef.obj == nil { - return l - } - l.objFunc[fdef.obj] = n - case *ast.BlockStmt: - l.blocks = append(l.blocks, t) - } - return l -} - -// Returns true if the string matches the format of a relative import -func isRelativeImport(s string) bool { - return strings.HasPrefix(s, ".") -} diff --git a/go/tests/rc/rc_test.go b/go/tests/rc/rc_test.go deleted file mode 100644 index 41ac188e3..000000000 --- a/go/tests/rc/rc_test.go +++ /dev/null @@ -1,151 +0,0 @@ -package main - -import ( - "sort" - "strings" - "testing" - - "github.com/01-edu/z01" -) - -func TestFlags(t *testing.T) { - argsAndSolution := map[string]string{ - "tests/testingSimpleFunc.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import regexp tests/testingSimpleFunc.go:4:2 - illegal-call len tests/testingSimpleFunc.go:10:9 - illegal-access regexp.MustCompile tests/testingSimpleFunc.go:8:8 - illegal-definition SimpleFunc tests/testingSimpleFunc.go:7:1 -`, - - "-no-for -no-lit=[a-z] tests/printalphabet/printalphabet.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import fmt tests/printalphabet/printalphabet.go:4:2 - illegal-import github.com/01-edu/z01 tests/printalphabet/printalphabet.go:6:2 - illegal-call append tests/printalphabet/printalphabet.go:11:7 - illegal-definition fillArray tests/printalphabet/printalphabet.go:9:1 - illegal-call int tests/printalphabet/printalphabet.go:17:7 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:19:3 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:21:2 - illegal-definition main tests/printalphabet/printalphabet.go:15:1 - illegal-access fmt.Println tests/printalphabet/printalphabet.go:26:3 - illegal-definition defFun tests/printalphabet/printalphabet.go:25:2 - illegal-call defFun tests/printalphabet/printalphabet.go:28:2 - illegal-definition testingScope tests/printalphabet/printalphabet.go:24:1 - illegal-loop for tests/printalphabet/printalphabet.go:10:2 - illegal-lit 'a' tests/printalphabet/printalphabet.go:10:11 - illegal-lit 'z' tests/printalphabet/printalphabet.go:10:21 - illegal-lit 'a' tests/printalphabet/printalphabet.go:16:14 - illegal-lit 'b' tests/printalphabet/printalphabet.go:16:19 - illegal-lit 'c' tests/printalphabet/printalphabet.go:16:24 - illegal-lit 'd' tests/printalphabet/printalphabet.go:16:29 - illegal-lit 'e' tests/printalphabet/printalphabet.go:16:34 - illegal-lit 'f' tests/printalphabet/printalphabet.go:16:39 - illegal-lit 'a' tests/printalphabet/printalphabet.go:17:11 - illegal-lit '\n' tests/printalphabet/printalphabet.go:21:16 - illegal-lit "Hello" tests/printalphabet/printalphabet.go:28:9 -`, - "-cast tests/eightqueens.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import github.com/01-edu/z01 tests/eightqueens.go:4:2 - illegal-access z01.PrintRune tests/eightqueens.go:49:5 - illegal-access z01.PrintRune tests/eightqueens.go:55:2 - illegal-definition printQueens tests/eightqueens.go:42:1 -`, - "-no-array tests/printalphabet/printalphabet.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import fmt tests/printalphabet/printalphabet.go:4:2 - illegal-import github.com/01-edu/z01 tests/printalphabet/printalphabet.go:6:2 - illegal-call append tests/printalphabet/printalphabet.go:11:7 - illegal-definition fillArray tests/printalphabet/printalphabet.go:9:1 - illegal-call int tests/printalphabet/printalphabet.go:17:7 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:19:3 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:21:2 - illegal-definition main tests/printalphabet/printalphabet.go:15:1 - illegal-access fmt.Println tests/printalphabet/printalphabet.go:26:3 - illegal-definition defFun tests/printalphabet/printalphabet.go:25:2 - illegal-call defFun tests/printalphabet/printalphabet.go:28:2 - illegal-definition testingScope tests/printalphabet/printalphabet.go:24:1 - illegal-slice rune tests/printalphabet/printalphabet.go:9:18 - illegal-slice rune tests/printalphabet/printalphabet.go:16:7 -`, - "-no-slices tests/printalphabet/printalphabet.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import fmt tests/printalphabet/printalphabet.go:4:2 - illegal-import github.com/01-edu/z01 tests/printalphabet/printalphabet.go:6:2 - illegal-call append tests/printalphabet/printalphabet.go:11:7 - illegal-definition fillArray tests/printalphabet/printalphabet.go:9:1 - illegal-call int tests/printalphabet/printalphabet.go:17:7 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:19:3 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:21:2 - illegal-definition main tests/printalphabet/printalphabet.go:15:1 - illegal-access fmt.Println tests/printalphabet/printalphabet.go:26:3 - illegal-definition defFun tests/printalphabet/printalphabet.go:25:2 - illegal-call defFun tests/printalphabet/printalphabet.go:28:2 - illegal-definition testingScope tests/printalphabet/printalphabet.go:24:1 - illegal-slice rune tests/printalphabet/printalphabet.go:9:18 - illegal-slice rune tests/printalphabet/printalphabet.go:16:7 -`, - "-no-these-slices=int,rune tests/printalphabet/printalphabet.go": `Cheating: - TYPE: NAME: LOCATION: - illegal-import fmt tests/printalphabet/printalphabet.go:4:2 - illegal-import github.com/01-edu/z01 tests/printalphabet/printalphabet.go:6:2 - illegal-call append tests/printalphabet/printalphabet.go:11:7 - illegal-definition fillArray tests/printalphabet/printalphabet.go:9:1 - illegal-call int tests/printalphabet/printalphabet.go:17:7 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:19:3 - illegal-access z01.PrintRune tests/printalphabet/printalphabet.go:21:2 - illegal-definition main tests/printalphabet/printalphabet.go:15:1 - illegal-access fmt.Println tests/printalphabet/printalphabet.go:26:3 - illegal-definition defFun tests/printalphabet/printalphabet.go:25:2 - illegal-call defFun tests/printalphabet/printalphabet.go:28:2 - illegal-definition testingScope tests/printalphabet/printalphabet.go:24:1 - illegal-slice rune tests/printalphabet/printalphabet.go:9:18 - illegal-slice rune tests/printalphabet/printalphabet.go:16:7 -`, - `-allow-builtin tests/doopprog/main.go fmt.Println strconv.Atoi os.Args`: ``, - `-cast tests/doopprog/main.go fmt.Println strconv.Atoi os.Args len`: ``, - `tests/testingWrapping.go`: `Cheating: - TYPE: NAME: LOCATION: - illegal-call len tests/utilDepth2/wrapper.go:4:9 - illegal-definition LenWrapper tests/utilDepth2/wrapper.go:3:1 - illegal-access util2.LenWrapper tests/util/util.go:10:9 - illegal-definition LenWrapperU tests/util/util.go:9:1 - illegal-access util.LenWrapperU tests/testingWrapping.go:8:9 - illegal-definition Length tests/testingWrapping.go:7:1 -`, - `tests/testingWrapping.go len`: ``, - `tests/empty/empty len`: ` stat : no such file or directory -`, - `tests/empty/empty.go tests/empty/empty`: ` tests/empty/empty.go:1:1: expected ';', found 'EOF' (and 2 more errors) -`, - `tests/abc/main.go --cast github.com/01-edu/z01.PrintRune#2 --no-lit=[b-mB-Y]`: ``, - `itoa.go len --cast`: ` stat itoa.go: no such file or directory -`, - } - Compare(t, argsAndSolution) -} - -func Compare(t *testing.T, argsAndSol map[string]string) { - for args, expected := range argsAndSol { - a := strings.Split(args, " ") - _, err := z01.MainOut("../rc", a...) - if err != nil && !EqualResult(expected, err.Error()) { - t.Errorf("./rc %s prints %q\n instead of %q\n", args, err.Error(), expected) - } - } -} - -func EqualResult(sol, out string) bool { - // split - solSli := strings.Split(sol, "\n") - outSli := strings.Split(out, "\n") - // sort - sort.Sort(sort.StringSlice(solSli)) - sort.Sort(sort.StringSlice(outSli)) - // join - sol = strings.Join(solSli, " ") - out = strings.Join(outSli, " ") - // compare - return sol == out -} diff --git a/go/tests/rc/tests/abc/main.go b/go/tests/rc/tests/abc/main.go deleted file mode 100644 index d10c5a88b..000000000 --- a/go/tests/rc/tests/abc/main.go +++ /dev/null @@ -1,10 +0,0 @@ -package main - -import "github.com/01-edu/z01" - -func main() { - for r := 'a'; r <= 'z'; r++ { - z01.PrintRune(r) - } - z01.PrintRune('\n') -} diff --git a/go/tests/rc/tests/doopprog/main.go b/go/tests/rc/tests/doopprog/main.go deleted file mode 100644 index 011902685..000000000 --- a/go/tests/rc/tests/doopprog/main.go +++ /dev/null @@ -1,214 +0,0 @@ -// package main - -// import ( -// "fmt" -// "os" -// "strconv" -// ) - -// level 3: doopprog - -package main - -import ( - "fmt" - "os" - "strconv" -) - -func main() { - args := os.Args - - if len(args) != 4 { - return - } - - if args[2] != "+" && args[2] != "-" && args[2] != "/" && args[2] != "*" && args[2] != "%" { - fmt.Println(0) - return - } - - // arg1 := getArg(args[1]) - - arg1, err := strconv.Atoi(args[1]) - if err != nil { - fmt.Println(0) - return - } - //fmt.Println("Arg1: ", arg1) - - arg2, err := strconv.Atoi(args[3]) - if err != nil { - fmt.Println(0) - return - } - //fmt.Println("Arg2: ", arg2) - - if args[2] == "+" { - Add(int64(arg1), int64(arg2)) - } else if args[2] == "-" { - Subs(int64(arg1), int64(arg2)) - } else if args[2] == "/" { - Div(int64(arg1), int64(arg2)) - } else if args[2] == "*" { - Multip(int64(arg1), int64(arg2)) - } else if args[2] == "%" { - Modulo(int64(arg1), int64(arg2)) - } - -} - -var max int64 = 9223372036854775807 -var min int64 = -9223372036854775808 - -func Add(x, y int64) { - if x >= 0 && y < 0 { - Subs(x, -y) - return - } else if x < 0 && y >= 0 { - Subs(y, -x) - return - } else if x < 0 && y < 0 { - if x >= min-y { - fmt.Println(x + y) - return - } else { - fmt.Println(0) - return - } - } - - if x <= max-y { - fmt.Println(x + y) - } else { - fmt.Println(0) - return - } -} - -func Subs(x, y int64) { - if x >= 0 && y < 0 { - Add(x, -y) - return - } else if x < 0 && y >= 0 { - Add(-y, x) - return - } else if x < 0 && y < 0 { - Subs(-y, -x) - return - } - - if x >= min+y { - fmt.Println(x - y) - return - } else { - fmt.Println(0) - return - } -} - -func Multip(x, y int64) { - if x >= 0 && y >= 0 { - if x <= max/y { - fmt.Println(x * y) - return - } else { - fmt.Println(0) - return - } - } else if x < 0 && y < 0 { - if x > max/y { - fmt.Println(x * y) - return - } else { - fmt.Println(0) - return - } - } else { - if x >= min/y { - fmt.Println(x * y) - return - } else { - fmt.Println(0) - return - } - } -} - -func Div(x, y int64) { - if y == 0 { - fmt.Println("No division by 0") - return - } - if x == min && y == -1 { - fmt.Println(0) - return - } - fmt.Println(x / y) - return -} - -func Modulo(x, y int64) { - if y == 0 { - fmt.Println("No modulo by 0") - return - } - if y == min && x == -1 { - fmt.Println(0) - return - } - fmt.Println(x % y) - return -} - -//9223372036854775807 -// func main() { -// if len(os.Args) == 4 { -// var result int -// firstArg, err := strconv.Atoi(os.Args[1]) - -// if err != nil { -// fmt.Println(0) -// return -// } - -// operator := os.Args[2] -// secondArg, err1 := strconv.Atoi(os.Args[3]) - -// if err1 != nil { -// fmt.Println(0) -// return -// } - -// if secondArg == 0 && operator == "/" { -// fmt.Println("No division by 0") -// return -// } else if secondArg == 0 && operator == "%" { -// fmt.Println("No modulo by 0") -// return -// } else if operator == "+" { -// result = firstArg + secondArg -// if !((result > firstArg) == (secondArg > 0)) { -// fmt.Println(0) -// return -// } -// } else if operator == "-" { -// result = firstArg - secondArg -// if !((result < firstArg) == (secondArg > 0)) { -// fmt.Println(0) -// return -// } -// } else if operator == "/" { -// result = firstArg / secondArg -// } else if operator == "*" { -// result = firstArg * secondArg -// if firstArg != 0 && (result/firstArg != secondArg) { -// fmt.Println(0) -// return -// } -// } else if operator == "%" { -// result = firstArg % secondArg -// } -// fmt.Println(result) -// } -// } diff --git a/go/tests/rc/tests/eightqueens.go b/go/tests/rc/tests/eightqueens.go deleted file mode 100644 index 833faab79..000000000 --- a/go/tests/rc/tests/eightqueens.go +++ /dev/null @@ -1,86 +0,0 @@ -package solutions - -import ( - "github.com/01-edu/z01" -) - -const size = 8 - -// board is a chessboard composed of boolean squares, a true square means a queen is on it -// a false square means it is a free square -var board [size][size]bool - -// goodDirection check that there is no queen on the segment that starts at (x, y) -// coordinates, points into the direction vector (vx, vy) and ends at the edge of the board -func goodDirection(x, y, vx, vy int) bool { - // x and y are still on board - for 0 <= x && x < size && - 0 <= y && y < size { - if board[x][y] { - // Not a good line : the square is already occupied - return false - } - x = x + vx // Move x in the right direction - y = y + vy // Move y in the right direction - } - // All clear - return true -} - -// goodSquare makes all the necessary line checks for the queens movements -func goodSquare(x, y int) bool { - return goodDirection(x, y, +0, -1) && - goodDirection(x, y, +1, -1) && - goodDirection(x, y, +1, +0) && - goodDirection(x, y, +1, +1) && - goodDirection(x, y, +0, +1) && - goodDirection(x, y, -1, +1) && - goodDirection(x, y, -1, +0) && - goodDirection(x, y, -1, -1) -} - -func printQueens() { - x := 0 - for x < size { - y := 0 - for y < size { - if board[x][y] { - // We have found a queen, let's print her y - z01.PrintRune(rune(y) + '1') - } - y++ - } - x++ - } - z01.PrintRune('\n') -} - -// tryX tries, for a given x (column) to find a y (row) so that the queen on (x, y) is a part -// of the solution to the problem -func tryX(x int) { - y := 0 - for y < size { - if goodSquare(x, y) { - // Since the square is good for the queen, let's put one on it: - board[x][y] = true - - if x == size-1 { - // x is the biggest possible x, it means that we just placed the last - // queen on the board, so the solution is complete and we can print it - printQueens() - } else { - // let's try to put another queen on the next empty x (column) - tryX(x + 1) - } - - // remove the queen of the board, to try other y values - board[x][y] = false - } - y++ - } -} - -func EightQueens() { - // try the first column - tryX(0) -} diff --git a/go/tests/rc/tests/empty/empty b/go/tests/rc/tests/empty/empty deleted file mode 100644 index e69de29bb..000000000 diff --git a/go/tests/rc/tests/empty/empty.go b/go/tests/rc/tests/empty/empty.go deleted file mode 100644 index e69de29bb..000000000 diff --git a/go/tests/rc/tests/example.go b/go/tests/rc/tests/example.go deleted file mode 100644 index fa7e4f35c..000000000 --- a/go/tests/rc/tests/example.go +++ /dev/null @@ -1,25 +0,0 @@ -package solutions - -import ( - "fmt" -) - -func thisIsAFunc() { - fmt.Println("This is a function") -} - -var ThisToo = func(s string) { - fmt.Printf("ThisToo prints %s\n", s) -} - -func aux(s string) int { - return 1 -} - -func youCanAlso(f func(string), s string) { - aux := func(s string) int { - return len(s) - } - aux(s) - f(s) -} diff --git a/go/tests/rc/tests/grand-prix-go-burdeux/isnegative.go b/go/tests/rc/tests/grand-prix-go-burdeux/isnegative.go deleted file mode 100644 index 52795b220..000000000 --- a/go/tests/rc/tests/grand-prix-go-burdeux/isnegative.go +++ /dev/null @@ -1,11 +0,0 @@ -package piscine - -import "github.com/01-edu/z01" - -func IsNegative(nb int) { - if nb < 0 { - z01.PrintRune('T') - } else { - z01.PrintRune('F') - } -} diff --git a/go/tests/rc/tests/moreThanOnePackage/func.go b/go/tests/rc/tests/moreThanOnePackage/func.go deleted file mode 100644 index e7a82f917..000000000 --- a/go/tests/rc/tests/moreThanOnePackage/func.go +++ /dev/null @@ -1,5 +0,0 @@ -package piscine - -func hello() { - println("Nothing here") -} diff --git a/go/tests/rc/tests/moreThanOnePackage/main.go b/go/tests/rc/tests/moreThanOnePackage/main.go deleted file mode 100644 index d2c4e91ea..000000000 --- a/go/tests/rc/tests/moreThanOnePackage/main.go +++ /dev/null @@ -1,7 +0,0 @@ -package main - -import "fmt" - -func main() { - fmt.Println("Hello world") -} diff --git a/go/tests/rc/tests/nesting/main.go b/go/tests/rc/tests/nesting/main.go deleted file mode 100644 index b84133ec8..000000000 --- a/go/tests/rc/tests/nesting/main.go +++ /dev/null @@ -1,16 +0,0 @@ -package main - -import "fmt" - -func myFunction(s string) bool { - return s > "m" -} - -func main() { - // myFunction := func(s string) bool { - // return s < "m" - // } - - fmt.Printf("Does %s comes before \"m\" %v\n", "name", myFunction("name")) - fmt.Printf("Does %s comes before \"m\" %v\n", "change", myFunction("change")) -} diff --git a/go/tests/rc/tests/printalphabet/printalphabet.go b/go/tests/rc/tests/printalphabet/printalphabet.go deleted file mode 100644 index 10a5cd828..000000000 --- a/go/tests/rc/tests/printalphabet/printalphabet.go +++ /dev/null @@ -1,29 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/01-edu/z01" -) - -func fillArray(a []rune) { - for i := 'a'; i <= 'z'; i++ { - a = append(a, i) - } -} - -func main() { - a := []rune{'a', 'b', 'c', 'd', 'e', 'f'} - b := int('a') - for _, v := range a { - z01.PrintRune(v) - } - z01.PrintRune('\n') -} - -func testingScope() { - defFun := func(s string) { - fmt.Println(s) - } - defFun("Hello") -} diff --git a/go/tests/rc/tests/testLiteralRestriction/main.go b/go/tests/rc/tests/testLiteralRestriction/main.go deleted file mode 100644 index 64a8606e8..000000000 --- a/go/tests/rc/tests/testLiteralRestriction/main.go +++ /dev/null @@ -1,10 +0,0 @@ -package main - -import "github.com/01-edu/z01" - -func main() { - alphabet := "abcdefghijklmnopqrstuvwxyz\n" - for _, letter := range alphabet { - z01.PrintRune(letter) - } -} diff --git a/go/tests/rc/tests/testingRepetitions/main.go b/go/tests/rc/tests/testingRepetitions/main.go deleted file mode 100644 index ebed01412..000000000 --- a/go/tests/rc/tests/testingRepetitions/main.go +++ /dev/null @@ -1,19 +0,0 @@ -package main - -import "github.com/01-edu/z01" - -func main() { - z01.PrintRune('a') - z01.PrintRune('b') - z01.PrintRune('c') - z01.PrintRune('d') - z01.PrintRune('e') - z01.PrintRune('f') - z01.PrintRune('g') - z01.PrintRune('h') - z01.PrintRune('i') - z01.PrintRune('j') - z01.PrintRune('k') - z01.PrintRune('l') - z01.PrintRune('m') -} diff --git a/go/tests/rc/tests/testingSimpleFunc.go b/go/tests/rc/tests/testingSimpleFunc.go deleted file mode 100644 index fadd048e9..000000000 --- a/go/tests/rc/tests/testingSimpleFunc.go +++ /dev/null @@ -1,11 +0,0 @@ -package solutions - -import ( - "regexp" -) - -func SimpleFunc(str string) int { - re := regexp.MustCompile(`[a-zA-Z]`) - found := re.FindAll([]byte(str), -1) - return len(found) -} diff --git a/go/tests/rc/tests/testingWrapping.go b/go/tests/rc/tests/testingWrapping.go deleted file mode 100644 index 23228adb3..000000000 --- a/go/tests/rc/tests/testingWrapping.go +++ /dev/null @@ -1,12 +0,0 @@ -package solutions - -import ( - util "./util" -) - -func Length(ss []string) int { - return util.LenWrapperU(ss) -} - -// func NotUsed() { -// } diff --git a/go/tests/rc/tests/util/util.go b/go/tests/rc/tests/util/util.go deleted file mode 100644 index e9094c252..000000000 --- a/go/tests/rc/tests/util/util.go +++ /dev/null @@ -1,23 +0,0 @@ -package util - -import ( - "fmt" - - util2 "../utilDepth2" -) - -func LenWrapperU(ss []string) int { - return util2.LenWrapper(ss) -} - -func NotUsed() { - b := []string{"just", "something"} - a := len(b) - for i, v := range b { - if i == a-1 { - fmt.Println("Last element", v) - continue - } - fmt.Println("Element", v) - } -} diff --git a/go/tests/rc/tests/utilDepth2/wrapper.go b/go/tests/rc/tests/utilDepth2/wrapper.go deleted file mode 100644 index 7ab08d523..000000000 --- a/go/tests/rc/tests/utilDepth2/wrapper.go +++ /dev/null @@ -1,5 +0,0 @@ -package util - -func LenWrapper(ss []string) int { - return len(ss) -}