host.go

Documentation: cmd/cgo/internal/testplugin/testdata/host

     1  // Copyright 2016 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"fmt"
     9  	"log"
    10  	"path/filepath"
    11  	"plugin"
    12  	"strings"
    13  
    14  	"testplugin/common"
    15  )
    16  
    17  func init() {
    18  	common.X *= 5
    19  }
    20  
    21  // testUnnamed tests that two plugins built with .go files passed on
    22  // the command line do not have overlapping symbols. That is,
    23  // unnamed1.so/FuncInt and unnamed2.so/FuncInt should be distinct functions.
    24  func testUnnamed() {
    25  	p, err := plugin.Open("unnamed1.so")
    26  	if err != nil {
    27  		log.Fatalf(`plugin.Open("unnamed1.so"): %v`, err)
    28  	}
    29  	fn, err := p.Lookup("FuncInt")
    30  	if err != nil {
    31  		log.Fatalf(`unnamed1.so: Lookup("FuncInt") failed: %v`, err)
    32  	}
    33  	if got, want := fn.(func() int)(), 1; got != want {
    34  		log.Fatalf("unnamed1.so: FuncInt()=%d, want %d", got, want)
    35  	}
    36  
    37  	p, err = plugin.Open("unnamed2.so")
    38  	if err != nil {
    39  		log.Fatalf(`plugin.Open("unnamed2.so"): %v`, err)
    40  	}
    41  	fn, err = p.Lookup("FuncInt")
    42  	if err != nil {
    43  		log.Fatalf(`unnamed2.so: Lookup("FuncInt") failed: %v`, err)
    44  	}
    45  	if got, want := fn.(func() int)(), 2; got != want {
    46  		log.Fatalf("unnamed2.so: FuncInt()=%d, want %d", got, want)
    47  	}
    48  }
    49  
    50  func main() {
    51  	if got, want := common.X, 3*5; got != want {
    52  		log.Fatalf("before plugin load common.X=%d, want %d", got, want)
    53  	}
    54  
    55  	p, err := plugin.Open("plugin1.so")
    56  	if err != nil {
    57  		log.Fatalf("plugin.Open failed: %v", err)
    58  	}
    59  
    60  	const wantX = 3 * 5 * 7
    61  	if got := common.X; got != wantX {
    62  		log.Fatalf("after plugin load common.X=%d, want %d", got, wantX)
    63  	}
    64  
    65  	seven, err := p.Lookup("Seven")
    66  	if err != nil {
    67  		log.Fatalf(`Lookup("Seven") failed: %v`, err)
    68  	}
    69  	if got, want := *seven.(*int), 7; got != want {
    70  		log.Fatalf("plugin1.Seven=%d, want %d", got, want)
    71  	}
    72  
    73  	readFunc, err := p.Lookup("ReadCommonX")
    74  	if err != nil {
    75  		log.Fatalf(`plugin1.Lookup("ReadCommonX") failed: %v`, err)
    76  	}
    77  	if got := readFunc.(func() int)(); got != wantX {
    78  		log.Fatalf("plugin1.ReadCommonX()=%d, want %d", got, wantX)
    79  	}
    80  
    81  	// sub/plugin1.so is a different plugin with the same name as
    82  	// the already loaded plugin. It also depends on common. Test
    83  	// that we can load the different plugin, it is actually
    84  	// different, and that it sees the same common package.
    85  	subpPath, err := filepath.Abs("sub/plugin1.so")
    86  	if err != nil {
    87  		log.Fatalf("filepath.Abs(%q) failed: %v", subpPath, err)
    88  	}
    89  	subp, err := plugin.Open(subpPath)
    90  	if err != nil {
    91  		log.Fatalf("plugin.Open(%q) failed: %v", subpPath, err)
    92  	}
    93  
    94  	funcVar, err := subp.Lookup("FuncVar")
    95  	if err != nil {
    96  		log.Fatalf(`sub/plugin1.Lookup("FuncVar") failed: %v`, err)
    97  	}
    98  	called := false
    99  	*funcVar.(*func()) = func() {
   100  		called = true
   101  	}
   102  
   103  	readFunc, err = subp.Lookup("ReadCommonX")
   104  	if err != nil {
   105  		log.Fatalf(`sub/plugin1.Lookup("ReadCommonX") failed: %v`, err)
   106  	}
   107  	if got := readFunc.(func() int)(); got != wantX {
   108  		log.Fatalf("sub/plugin1.ReadCommonX()=%d, want %d", got, wantX)
   109  	}
   110  	if !called {
   111  		log.Fatal("calling ReadCommonX did not call FuncVar")
   112  	}
   113  
   114  	subf, err := subp.Lookup("F")
   115  	if err != nil {
   116  		log.Fatalf(`sub/plugin1.Lookup("F") failed: %v`, err)
   117  	}
   118  	if gotf := subf.(func() int)(); gotf != 17 {
   119  		log.Fatalf(`sub/plugin1.F()=%d, want 17`, gotf)
   120  	}
   121  	f, err := p.Lookup("F")
   122  	if err != nil {
   123  		log.Fatalf(`plugin1.Lookup("F") failed: %v`, err)
   124  	}
   125  	if gotf := f.(func() int)(); gotf != 3 {
   126  		log.Fatalf(`plugin1.F()=%d, want 17`, gotf)
   127  	}
   128  
   129  	p2, err := plugin.Open("plugin2.so")
   130  	if err != nil {
   131  		log.Fatalf("plugin.Open failed: %v", err)
   132  	}
   133  	// Check that plugin2's init function was called, and
   134  	// that it modifies the same global variable as the host.
   135  	if got, want := common.X, 2; got != want {
   136  		log.Fatalf("after loading plugin2, common.X=%d, want %d", got, want)
   137  	}
   138  
   139  	_, err = plugin.Open("plugin2-dup.so")
   140  	if err == nil {
   141  		log.Fatal(`plugin.Open("plugin2-dup.so"): duplicate open should have failed`)
   142  	}
   143  	if s := err.Error(); !strings.Contains(s, "already loaded") {
   144  		log.Fatal(`plugin.Open("plugin2.so"): error does not mention "already loaded"`)
   145  	}
   146  
   147  	_, err = plugin.Open("plugin-mismatch.so")
   148  	if err == nil {
   149  		log.Fatal(`plugin.Open("plugin-mismatch.so"): should have failed`)
   150  	}
   151  	if s := err.Error(); !strings.Contains(s, "different version") {
   152  		log.Fatalf(`plugin.Open("plugin-mismatch.so"): error does not mention "different version": %v`, s)
   153  	}
   154  
   155  	_, err = plugin.Open("plugin2-dup.so")
   156  	if err == nil {
   157  		log.Fatal(`plugin.Open("plugin2-dup.so"): duplicate open after bad plugin should have failed`)
   158  	}
   159  	_, err = plugin.Open("plugin2.so")
   160  	if err != nil {
   161  		log.Fatalf(`plugin.Open("plugin2.so"): second open with same name failed: %v`, err)
   162  	}
   163  
   164  	// Test that unexported types with the same names in
   165  	// different plugins do not interfere with each other.
   166  	//
   167  	// See Issue #21386.
   168  	UnexportedNameReuse, _ := p.Lookup("UnexportedNameReuse")
   169  	UnexportedNameReuse.(func())()
   170  	UnexportedNameReuse, _ = p2.Lookup("UnexportedNameReuse")
   171  	UnexportedNameReuse.(func())()
   172  
   173  	testUnnamed()
   174  
   175  	fmt.Println("PASS")
   176  }
   177
View as plain text