For standard community use `aa:nn` format, where `aa` and
                        `nn` are 16 bit number. For large community use `aa:nn:mm`
                        format, where `aa`, `nn` and `mm` are 32 bit number. Where,
                        `aa` is an AS Number, `nn` and `mm` are per-AS identifier.
                      pattern: ^(\d+):(\d+)$|^(\d+):(\d+):(\d+)$

	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, '.', tabwriter.AlignRight|tabwriter.Debug)
	fmt.Fprintln(w, "a\tb\tc")
	fmt.Fprintln(w, "aa\tbb\tcc")
	fmt.Fprintln(w, "aaa\t") // trailing tab
	fmt.Fprintln(w, "aaaa\tdddd\teeee")
	w.Flush()

	// output:
	// ....a|..b|c
	// ...aa|.bb|cc
	// ..aaa|
	// .aaaa|.dddd|eeee
}

func Example_trailingTab() {
	// Observe that the third line has no trailing tab,

import org.jetbrains.kotlin.test.services.TestServices

/**
 * The IDE can run analysis before calling CodeGen API. We found some cases that generate different FIR expressions between analysis
 * and CodeGen API. For example, AA generates `FirLiteralExpression` for an initializer of a property, while CodeGen API generates
 * `FirLazyExpression`. The difference can result in crashes. This class helps us test the IDE situation that first calls analysis

	}

	var columns []string
	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Model(&User{}).Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Find(&User{}).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

00000070  5f c5 ac e7 85 06 86 a4  21 10 aa 56 18 3a 39 14  |_.......!..V.:9.|
00000080  03 03 00 01 01 17 03 03  00 17 a8 c3 84 a3 a2 42  |...............B|
00000090  ba c8 40 ef f8 53 02 58  d7 39 3f b2 34 2f 4e 71  |..@..S.X.9?.4/Nq|
000000a0  54 17 03 03 02 6d e5 41  6d ac 46 4e 7c 71 5c b9  |T....m.Am.FN|q\.|
000000b0  c5 aa 8d 7d f2 ef f3 40  22 9d db d3 83 49 45 94  |...}...@"....IE.|

00000010  f3 48 de f0 8f 9e 12 ca  e0 ab 86 e0 7e e7 8b ea  |.H..........~...|
00000020  1a 76 3e 65 8d 7a d6 1c  72 2a f7 1e aa 0a 12 8f  |.v>e.z..r*......|
00000030  54 ac 33 95 9d 00 a9 a6  94 54 7b 6a d9 e3 f4 67  |T.3......T{j...g|
00000040  a6 d3 b1 c1 5d 86 51 aa  63 67 6b 6e cb 3b 5e 59  |....].Q.cgkn.;^Y|
00000050  02 c2 57 fd 37 39 1b 73  9a 61 b0 78 de e8 cc f8  |..W.79.s.a.x....|

00000080  b9 ee 39 e8 3f 2d 73 4d  21 fa 2e 05 b4 a1 02 64  |..9.?-sM!......d|
00000090  15 03 03 00 30 00 00 00  00 00 00 00 00 00 00 00  |....0...........|
000000a0  00 00 00 00 00 14 1e f7  64 d8 47 a6 93 aa 03 aa  |........d.G.....|
000000b0  7c f3 a2 fb b8 6f cf f2  0d e4 2d d1 d6 67 f3 6b  ||....o....-..g.k|

E	((..)|(.))*				a		(0,1)(0,1)(?,?)(0,1)

E	((..)|(.))				aa		(0,2)(0,2)(0,2)(?,?)
E	((..)|(.))((..)|(.))			aa		(0,2)(0,1)(?,?)(0,1)(1,2)(?,?)(1,2)
E	((..)|(.))((..)|(.))((..)|(.))		aa		NOMATCH

E	((..)|(.)){1}				aa		(0,2)(0,2)(0,2)(?,?)
E	((..)|(.)){2}				aa		(0,2)(1,2)(?,?)(1,2)
E	((..)|(.)){3}				aa		NOMATCH

E	((..)|(.))*				aa		(0,2)(0,2)(0,2)(?,?)

E	((..)|(.))				aaa		(0,2)(0,2)(0,2)(?,?)

        NetworkBuilder.directed().allowsSelfLoops(true).build();
    mutableNetwork.addEdge("A", "A", "AA");
    mutableNetwork.addEdge("A", "B", "AB");
    Network<String, String> network = ImmutableNetwork.copyOf(mutableNetwork);

    assertThat(network.edgesConnecting("A", "A")).containsExactly("AA");
    assertThat(network.edgesConnecting("A", "B")).containsExactly("AB");

00000030  38 8e bb 42 de e4 fb c6  9f df db 7f af 6c ae b5  |8..B.........l..|
00000040  6a 99 70 3c 1e 88 38 22  aa 1e 81 51 1e 7d 36 31  |j.p<..8"...Q.}61|
00000050  4e d2 a9 08 c0 bc 11 d8  27 41 26 75 f3 35 74 74  |N.......'A&u.5tt|
00000060  ef 50 0e 2b bd da 41 ed  81 56 b9 e4 13 74 e9 80  |.P.+..A..V...t..|
00000070  9f a2 90 d1 fd 85 26 02  f3 aa 75 53 d9 58 bc 2f  |......&...uS.X./|
00000080  3b e5 60 cb f8 ac e6 32  6e 5f 80 14 03 03 00 01  |;.`....2n_......|