### CAGED notation (part 2)

Source: https://github.com/tardate/jtab/blob/main/examples.htm

More examples of rendering CAGED chord shapes.

```html
<div class="jtab chordonly">C:6 C:7 C:8 C:9 C:10</div>
```

--------------------------------

### CAGED notation (part 3)

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Examples of rendering minor CAGED chord shapes.

```html
<div class="jtab chordonly">Cm:1 Cm:2 Cm:3 Cm:4 Cm:5</div>
```

--------------------------------

### CAGED notation (part 1)

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Examples of rendering CAGED chord shapes using jTab.

```html
<div class="jtab chordonly">C:1 C:2 C:3 C:4 C:5</div>
```

--------------------------------

### More than one note at a time in tab (part 1)

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Example showing how to represent more than one note at a time in tab notation.

```html
<div class="jtab tabonly">$3.6.$2.5h7 $1 5 $2 7 |</div>
```

--------------------------------

### Basic Tab Notation Examples

Source: https://github.com/tardate/jtab/blob/main/index.htm

Examples demonstrating how to enter basic note sequences on a single string, including fret positions, slides, hammer-ons, and pull-offs.

```text
$2 0 1 3
```

```text
$2 0 1 3 $1 0 1 3/5
```

```text
$B 0 1 3 $e 0 1 3/5
```

--------------------------------

### Multiple Notes at Once Examples

Source: https://github.com/tardate/jtab/blob/main/index.htm

Examples showing how to represent multiple notes played simultaneously on different strings by joining individual string notations with periods.

```text
$3.6.$2.5h7 $1 5 $2 7
```

```text
$4.7/9.$3.6/8.$2.5/7 9p7 $2.9.$3.9.$4.9
```

--------------------------------

### Implicitly render a mixed chord and tab phrase

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Shows how to render a phrase containing both chords and tab notation.

```html
<div class="jtab">Bm $3 4 4h5p3h4 5 $2 3 5 7 7h8p7 5/7 | A $4 7 9 $3 7 6 $5 9 $4 7h9 7 $5 9\7 5/7 ||</div>
```

--------------------------------

### Implicitly render a tab-only phrase

Source: https://github.com/tardate/jtab/blob/main/examples.htm

An example of implicitly rendering a tab-only phrase using a div with the 'jtab tabonly' classes.

```html
<div class="jtab tabonly">$4.7/9.$3.6/8.$2.5/7 9p7 $2.9.$3.9.$4.9 ||</div>
```

--------------------------------

### CAGED notation (part 4)

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Examples of rendering seventh chord CAGED shapes.

```html
<div class="jtab chordonly">Eb7:1 Eb7:2 Eb7:3 Eb7:4 Eb7:5</div>
```

--------------------------------

### Implicit Rendering Example

Source: https://github.com/tardate/jtab/blob/main/index.htm

Demonstrates how to perform implicit rendering by assigning the class 'jtab' to a block tag containing guitar notation.

```html
<div class="jtab"> E / / / | Am / B / || </div>
```

--------------------------------

### Implicitly render a custom named chord

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Demonstrates rendering a custom named chord using jTab's notation.

```html
<div class="jtab chordonly"> %7/2.X/X.7/3.7/4.6/1.X/X[Bm7b5] </div>
```

--------------------------------

### Scripted rendering

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Demonstrates rendering notation using jTab's JavaScript API, targeting a specific div.

```javascript
jtab.render($('#mytab'),'Am7 C');
```

--------------------------------

### Chord Notation Examples

Source: https://github.com/tardate/jtab/blob/main/index.htm

Examples for entering tab for a whole or partial chord as a six-string block, including shorthand for frets below the 10th, using periods for separation, and 'X' for muted strings.

```text
022100
```

```text
8.10.10.9.8.8
```

```text
X02220
```

--------------------------------

### Implicitly render a chord-only phrase

Source: https://github.com/tardate/jtab/blob/main/examples.htm

An example of implicitly rendering a chord-only phrase using a div with the 'jtab chordonly' classes.

```html
<div class="jtab chordonly"> E / / / | A7 / B7 / || </div>
```

--------------------------------

### Shorthand tab notation for all strings

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Example of shorthand tab notation for a whole or partial chord, using periods for frets above 9 and X for unused strings.

```html
<div class="jtab tabonly">022100 / / / X02220 / 8.10.10.9.8.8 / ||</div>
```

--------------------------------

### Implicit Rendering using CSS - Chords and Tab Notation

Source: https://github.com/tardate/jtab/blob/main/index.htm

Here's an example combining chords and tab notation.

```text
Bm $3 4 4h5p3h4 5 $2 3 5 7 7h8p7 5/7 | A $4 7 9 $3 7 6 $5 9 $4 7h9 7 $5 9\7 5/7 |
```

--------------------------------

### A simple three note sequence on the B (2nd) string

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Example of a simple three-note sequence on the B string in tab notation.

```html
<div class="jtab tabonly">$B 0 1 3 | $2 5 3 0 ||</div>
```

--------------------------------

### Customising the color palette

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Demonstrates how jTab uses CSS styles (color, background-color) of the enclosing element to customize the rendered notation.

```html
<div class="jtab" style="color:blue;background-color:yellow">Am $e 3 1 0</div>
```

--------------------------------

### A sequence of notes across two strings

Source: https://github.com/tardate/jtab/blob/main/examples.htm

Demonstrates using both 654321 and EADGBe for string numbering in tab notation.

```html
<div class="jtab tabonly">$2 0 1 3 $1 0 1 3/5 | $B 0 1 3 $e 0 1 3/5 ||</div>
```

--------------------------------

### Custom Chord Notation Example

Source: https://github.com/tardate/jtab/blob/main/index.htm

jTab also supports custom chord notation, where the frets and fingers for any arbitrary chord can be explicitly defined.

```text
%7/2.X/X.7/3.7/4.6/1.X/X[Bm7b5]
```

--------------------------------

### Render notation provided by a user

Source: https://github.com/tardate/jtab/blob/main/examples.htm

This snippet shows how to dynamically render user-provided notation using jTab. It listens for keyup events on an element with the ID 'notation' and renders the input into an element with the ID 'tab'.

```javascript
jtab.render($('#tab'),$(this).val());
```

--------------------------------

### Pre-sizing jTab Elements with CSS

Source: https://github.com/tardate/jtab/blob/main/index.htm

Provides examples of using CSS classes to pre-size jTab elements for different content types (chord and tab, chord only, tab only) to prevent page layout jitters.

```html
<div class="jtab">(pre-sized for chord and tab)</div>
<div class="jtab chordonly">(pre-sized for chord only)</div>
<div class="jtab tabonly">(pre-sized for tab only)</div>
```

--------------------------------

### jTab Javascript Inclusion

Source: https://github.com/tardate/jtab/blob/main/index.htm

Example of how to include the jTab Javascript files, along with jQuery and Raphaël, in the HTML head section of a web page.

```html
<head>
  ... (other stuff) ...
  <meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" />
  <link type="text/css" rel="stylesheet" href="http://jtab.tardate.com/css/jtab-helper.css"/>

  <script src="https://jtab.tardate.com/javascripts/jquery.js" type="text/javascript"></script>
  <script src="https://jtab.tardate.com/javascripts/raphael.js" type="text/javascript"></script>
  <script src="https://jtab.tardate.com/javascripts/jtab.js" type="text/javascript"></script>

</head>
```

--------------------------------

### Explicit Call to Rendering Function

Source: https://github.com/tardate/jtab/blob/main/index.htm

An example of explicitly calling the jtab.renderimplicit() function, which can be used as a workaround if implicit rendering is not happening due to conflicts with other onload handlers.

```javascript
jtab.renderimplicit();
```

--------------------------------

### Implicit Rendering using CSS - Chord Phrase

Source: https://github.com/tardate/jtab/blob/main/index.htm

jTab implicitly renders tab notation on a web page that is contained in blocks marked with the special class name 'jtab'. This can be used for posting transcriptions to your blog for example - just include jTab in your blog template then when posting you don't need to remember anything else except to set the class name on your notation. Here, a chord phrase is written directly into the web page.

```text
E / / / | A7 / B7 / ||
```

--------------------------------

### Implicit Rendering using CSS - Tab Notation Only

Source: https://github.com/tardate/jtab/blob/main/index.htm

Or just tab notation..

```text
$4.7/9.$3.6/8.$2.5/7 9p7 $2.9.$3.9.$4.9
```

--------------------------------

### Interactive/Explicit Rendering using Javascript

Source: https://github.com/tardate/jtab/blob/main/index.htm

jTab can be used to render notation in real-time using Javascript. This could be based on user input (like here), or with the notation feed being generated or retrieved from some system or web service.

```javascript
$('#user_notation').keyup(function(e){ jtab.render($('#tab'),$(this).val()); });
```

--------------------------------

### Unit Tests for jTab

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

This section contains unit tests for the core algorithms in jtab.js, covering various aspects of chord and tab notation recognition.

```javascript
// <!CDATA[ new Test.Unit.Runner({
 setup: function() { },
 teardown: function() { },
 testUnitTestFrameworkOperational: function() { with(this) { assert(true); }},
 testRaphaelGetStringNumber: function() { with(this) { var token = "$1";
 var expected = 1;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$2";
 expected = 2;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$3";
 expected = 3;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$4";
 expected = 4;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$5";
 expected = 5;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$6";
 expected = 6;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$e";
 expected = 1;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$B";
 expected = 2;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$G";
 expected = 3;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$D";
 expected = 4;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$A";
 expected = 5;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );

 token = "$E";
 expected = 6;
 assertEqual( expected, Raphael.fn.get_string_number(token), "incorrect string number for: '" + token + "'" );
 }},
 testRecognizeChordAndTabNotation: function() { with(this) {
 var notation = "Bm $3 4 4h5p3h4 5 $2 3 5 7 7h8p7 5/7 | A $4 7 9 $3 7 6 $5 9 $4 7h9 7 $5 9\7 5/7 | ";
 var tabtype = jtab.characterize( notation );
 assertEqual( 1, tabtype, "not recognised as chord and tab notation: '" + notation + "'" );

 notation = "A7 $e 2 3 $B.3.$e.2";
 tabtype = jtab.characterize( notation );
 assertEqual( 1, tabtype, "not recognised as chord and tab notation: '" + notation + "'" );

 notation = "Bm $3 4 4h5p3h4 5 $2 3 5 7 7h8p7 5/7 ";
 tabtype = jtab.characterize( notation );
 assertEqual( 1, tabtype, "not recognised as chord and tab notation: '" + notation + "'" );
 }}},
 testRecognizeChordOnlyNotation: function() { with(this) {
 var notation = "A B C D E F G / | Ab Bb Db Eb Gb | A# C# D# F# G# || Am A6 Am6 A69 A7 Am7 Amaj7 A7b5 A7#5 Am7b5 A7b9 A9 Am9 Amaj9 Aadd9 A13 Asus2 Asus4 Adim Adim7 Aaug";
 var tabtype = jtab.characterize( notation );
 assertEqual( 2, tabtype, "not recognised as chord-only notation: '" + notation + "'" );
 }}},
 testRecognizeCustomChordOnlyNotation: function() { with(this) {
 // let's try a C chord
 var notation = "%X/X.4/3.2/2.0/0.1/1.0/0[C]";
 var tabtype = jtab.characterize( notation );
 assertEqual( 2, tabtype, "not recognised as custom-chord-only notation: '" + notation + "'" );
 }}},
 testRecognizeCustomChordNoNameNotation: function() { with(this) {
 // let's try a C chord, but don't include the name
 var notation = "%X/X.4/3.2/2.0/0.1/1.0/0";
 var tabtype = jtab.characterize( notation );
 assertEqual( 2, tabtype, "not recognised as custom-chord-only notation: '" + notation + "'" );
 }}},
 testRecognizeTabOnlyNotation: function() { with(this) {
 var notation = "$1 2 3 $2.3.$1.2";
 var tabtype = jtab.characterize( notation );
 assertEqual( 3, tabtype, "not recognised as tab-only notation: '" + notation + "'" );

 notation = "$e 2 3 $B.3.$e.2";
 tabtype = jtab.characterize( notation );
 assertEqual( 3, tabtype, "not recognised as tab-only notation: '" + notation + "'" );

 notation = "X02220 8.10.10.9.8.8";
 tabtype = jtab.characterize( notation );
 assertEqual( 3, tabtype, "not recognised as tab-only notation: '" + notation + "'" );
 }}},
 /* The western scale is commonly found in 'western pop' music. It consists of 12 notes that are 1 intervals apart to form an octave. Eg. C, C#, D, Eb, E, F, F#, G, G#, A, Bb, C Other notable scales such as the Pentatonic scale which consists of only 5 notes and the Indian scale which has 24 notes. We need to normalize the notes available to our western scale into base notes because the following pairs are equivalent. C# = Db D# = Eb F# = Gb G# = Ab A# = Bb It is just a matter of convention when we favoured C#, Eb, F#, G#, Bb over their equivalents in rendering our base notes. */
 testWesternScale: function() { with(this) {
 var scale = jtab.WesternScale;
 assertNotUndefined( scale, "jtab.WesternScale should be valid" );
 }},
 testWesternScaleBaseNotes: function() { with(this) {
 var baseNotes = jtab.WesternScale.BaseNotes

```

--------------------------------

### Standard Chord Fingering Test (C)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering and properties of a standard 'C' chord, ensuring it's not a CAGED chord and has the correct `chordArray`.

```javascript
var token = 'C';
var modelChordArray = [
    0,
    [-1],
    [3, 3],
    [2, 2],
    [0],
    [1, 1],
    [0]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(!c.isCaged, "jtabChord('" + token + "') should not be CAGED");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### Custom Chord Fingering Test (Empty Name)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the parsing of a custom chord string with an empty name.

```javascript
var token = "%0/0.2/2.3/2.1/1.0/0.0/0[]";
var modelChordArray = [
    0,
    [0, 0],
    [2, 2],
    [3, 2],
    [1, 1],
    [0, 0],
    [0, 0]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCustom, "jtabChord('" + token + "') should be custom chord");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### Test Chord A3 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'A:3' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_A3_fingering: function() { with(this) { var token = 'A:3'; var modelChordArray = [
    4,
    [5,1],
    [7,3],
    [7,4],
    [6,2],
    [5,1],
    [5,1]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Test Chord Dm7b5p2 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'Dm7b5:2' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_Dm7b5p2_fingering: function() { with(this) { var token = 'Dm7b5:2'; var modelChordArray = [
    1,
    [-1, null],
    [5,1],
    [6,3],
    [5,2],
    [6,4],
    [-1, null]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Custom Chord Fingering Test (Bm7b5)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the parsing and `chordArray` for a custom-defined chord 'Bm7b5'.

```javascript
var token = "%7/2.X/X.7/3.7/4.6/1.X/X[Bm7b5]";
var modelChordArray = [
    5,
    [7, 2],
    [-1],
    [7, 3],
    [7, 4],
    [6, 1],
    [-1]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCustom, "jtabChord('" + token + "') should be custom chord");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### Test Chord Dm7b5 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'Dm7b5' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_Dm7b5_fingering: function() { with(this) { var token = 'Dm7b5'; var modelChordArray = [
    0,
    [-1],
    [-1],
    [0],
    [1,1],
    [1,1],
    [1,1]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( ! c.isCaged, "jtabChord('" + token + "') should not be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Custom Chord Fingering Test (F)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the parsing and `chordArray` for a custom-defined chord 'F'.

```javascript
var token = "%8/2.X/X.7/1.10/4.X/X.X/X[F]";
var modelChordArray = [
    6,
    [8, 2],
    [-1],
    [7, 1],
    [10, 4],
    [-1],
    [-1]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCustom, "jtabChord('" + token + "') should be custom chord");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### Test Chord A Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'A' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_A_fingering: function() { with(this) { var token = 'A'; var modelChordArray = [
    0,
    [-1],
    [0],
    [2,2],
    [2,1],
    [2,3],
    [0]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( ! c.isCaged, "jtabChord('" + token + "') should not be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Test Chord Cm Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'Cm' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_Cm_fingering: function() { with(this) { var token = 'Cm'; var modelChordArray = [
    0,
    [-1],
    [3,4],
    [1,2],
    [0],
    [1,1],
    [-1]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( ! c.isCaged, "jtabChord('" + token + "') should not be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Custom Chord Fingering Test (No Name)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the parsing of a custom chord string that does not have an explicit name provided.

```javascript
var token = "%0/0.2/2.3/2.1/1.0/0.0/0";
var modelChordArray = [
    0,
    [0, 0],
    [2, 2],
    [3, 2],
    [1, 1],
    [0, 0],
    [0, 0]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCustom, "jtabChord('" + token + "') should be custom chord");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### Test Chord A1 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'A:1' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_A1_fingering: function() { with(this) { var token = 'A:1'; var modelChordArray = [
    0,
    [-1],
    [0],
    [2,2],
    [2,1],
    [2,3],
    [0]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Test Chord Cm2 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'Cm:2' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_Cm2_fingering: function() { with(this) { var token = 'Cm:2'; var modelChordArray = [
    2,
    [-1,-1],
    [3,1],
    [5,3],
    [5,4],
    [4,2],
    [3,1]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Test AddChord Update

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests updating an existing chord ('A') using jtab.AddChord and verifies its chord array.

```javascript
testChord_AddChord_update: function() { with(this) { var token = 'A'; var modelChordArray = [
    0,
    [-1],
    [0],
    [2,2],
    [2,1],
    [2,3],
    [0]
];
var modelChordArrayNew = [
    0,
    [-1],
    [0],
    [2,2],
    [2,2],
    [2,3],
    [0]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should initially be valid" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### CAGED Position Setting from Token Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Verifies that the CAGED position is correctly set from the chord token.

```javascript
var msg = "Caged position should follow position found in token";
var chord = new jtabChord('C:1');
var cagedPos = chord.cagedPos;
assertNotUndefined( cagedPos );
assertEqual( 1, cagedPos, msg );
chord = new jtabChord('C:2');
cagedPos = chord.cagedPos;
assertEqual( 2, cagedPos, msg );
chord = new jtabChord('C:3');
cagedPos = chord.cagedPos;
assertEqual( 3, cagedPos, msg );
chord = new jtabChord('C:4');
cagedPos = chord.cagedPos;
assertEqual( 4, cagedPos, msg );
```

--------------------------------

### Test Chord Cm1 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'Cm:1' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_Cm1_fingering: function() { with(this) { var token = 'Cm:1'; var modelChordArray = [
    0,
    [-1],
    [3,4],
    [1,2],
    [0],
    [1,1],
    [-1]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Custom Chord Fingering Test (E)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the parsing and `chordArray` for a custom-defined chord named 'E'.

```javascript
var token = "%0/0.2/2.3/2.1/1.0/0.0/0[E]";
var modelChordArray = [
    0,
    [0, 0],
    [2, 2],
    [3, 2],
    [1, 1],
    [0, 0],
    [0, 0]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCustom, "jtabChord('" + token + "') should be custom chord");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### jtabChord C#m Fingering Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the jtabChord constructor for 'C#m', verifying its validity, checking if it's a CAGED chord, and asserting the correctness of its chordArray.

```javascript
testChord_Csharpm_fingering: function() { with(this) { var token = 'C#m'; var modelChordArray = [ 0, [-1 ], [-1], [2,2], [1,1], [2,3], [0] ]; var c = new jtabChord(token); assert( c.isValid, "jtabChord('" + token + "') should be valid" ); assert( ! c.isCaged, "jtabChord('" + token + "') should not be CAGED" ); assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray" ); }}
```

--------------------------------

### Chord Root Note Recognition Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the recognition of the root note from a chord token.

```javascript
var msg = "Root note of chord should be correct";
var chord = new jtabChord('C');
assertEqual( 'C', chord.rootNote, msg );
chord = new jtabChord('C#');
assertEqual( 'C#', chord.rootNote, msg );
chord = new jtabChord('C#m');
assertEqual( 'C#', chord.rootNote, msg );
chord = new jtabChord('C#maj7');
assertEqual( 'C#', chord.rootNote, msg );
chord = new jtabChord('C#maj7:1');
assertEqual( 'C#', chord.rootNote, msg );
chord = new jtabChord('Db');
assertEqual( 'Db', chord.rootNote, msg );
chord = new jtabChord('Dbmaj7');
assertEqual( 'Db', chord.rootNote, msg );
chord = new jtabChord('Dbmaj7:2');
assertEqual( 'Db', chord.rootNote, msg );
```

--------------------------------

### Test AddChord Insert

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the functionality of adding a new chord ('ATest') using jtab.AddChord and verifies its validity and chord array.

```javascript
testChord_AddChord_insert: function() { with(this) { var token = 'ATest'; var modelChordArrayNew = [
    0,
    [-1],
    [0],
    [2,3],
    [2,2],
    [2,1],
    [0]
];
var c = new jtabChord(token);
assert( !c.isValid, "jtabChord('" + token + "') should not initially be valid" );
jtab.AddChord(token, [modelChordArrayNew]);
c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid after insert" );
assertHashEqual( modelChordArrayNew, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### CAGED Chord Fingering Test (C:1)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering and properties of a CAGED 'C' chord variant (C:1), ensuring it's identified as CAGED and has the correct `chordArray`.

```javascript
var token = 'C:1';
var modelChordArray = [
    0,
    [-1],
    [3, 3],
    [2, 2],
    [0],
    [1, 1],
    [0]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCaged, "jtabChord('" + token + "') should be CAGED");
assertHashEqual(modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray");
```

--------------------------------

### CAGED Chord Fingering Test (C:2)

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering and properties of a CAGED 'C' chord variant (C:2), ensuring it's identified as CAGED and has the correct `chordArray`.

```javascript
var token = 'C:2';
var modelChordArray = [
    2,
    [-1, -1],
    [3, 1],
    [5, 2],
    [5, 3],
    [5, 4],
    [3, 1]
];
var c = new jtabChord(token);
assert(c.isValid, "jtabChord('" + token + "') should be valid");
assert(c.isCaged, "jtabChord('" + token + "') should be CAGED");
assertHashEqual(modelChordArray, c.chordArray, "jta
```

--------------------------------

### Test Chord A2 Fingering

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the fingering for the 'A:2' chord, checking its validity, CAGED status, and chord array.

```javascript
testChord_A2_fingering: function() { with(this) { var token = 'A:2'; var modelChordArray = [
    1,
    [5,3],
    [4,2],
    [2,1],
    [2,1],
    [2,1],
    [5,4]
];
var c = new jtabChord(token);
assert( c.isValid, "jtabChord('" + token + "') should be valid" );
assert( c.isCaged, "jtabChord('" + token + "') should be CAGED" );
assertHashEqual( modelChordArray, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray"
); } }
```

--------------------------------

### Chord Chart Generation

Source: https://github.com/tardate/jtab/blob/main/jtab-chordchart.htm

JavaScript code to generate a chord chart by accumulating and rendering chord tokens.

```javascript
var chordList = jtab.ChordList();
function render_chord_chart(start) {
    var startAt = (start === undefined) ? 0 : start;
    var endAt = startAt + 5;
    var tokens = '';
    for (var key = startAt; key < endAt; key++) {
        if ( chordList[key] === undefined ) break;
        var token = chordList[key];
        // accumulate row tokens
        tokens += token + ' ';
    }
    // emit a new child to hold a row
    var rowHolder = $('<div id="builder_'+(jtab.element_count++)+'"></div>')
    $('#chart').append(rowHolder)
    jtab.render(rowHolder,tokens);
    // yield/async continuation of the chord chart if not yet complete
    if (endAt < chordList.length)
        setTimeout('render_chord_chart(' + endAt + ')', 0 );
}
```

--------------------------------

### Chord List Availability Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Checks if the jtab.ChordList function returns an array.

```javascript
var msg = "jtab.ChordList should be an array of all chord names";
var chordList = jtab.ChordList();
assertInstanceOf( Array, chordList, msg );
```

--------------------------------

### jtabChord AddChord and Update Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the AddChord method of jtab, verifying that a chord is correctly added and updated, and that the chordArray is accurate after the update.

```javascript
testChord_update: function() { with(this) { var token = 'Dm'; var modelChordArrayOld = [ 0, [2,2], [3,3], [2,4], [1,1], [0] ]; var modelChordArrayNew = [ 0, [2,2], [3,3], [2,4], [1,1], [0] ]; var c = new jtabChord(token); assert( c.isValid, "jtabChord('" + token + "') should be valid before update" ); assertHashEqual( modelChordArrayOld, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray before update" ); jtab.AddChord(token, modelChordArrayNew); c = new jtabChord(token); assert( c.isValid, "jtabChord('" + token + "') should be valid after update" ); assertHashEqual( modelChordArrayNew, c.chordArray, "jtabChord('" + token + "') returned incorrect chordArray after update" ); }}
```

--------------------------------

### CAGED Base Shape Setting from Token Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests that the CAGED base shape is derived correctly from the root note in the token.

```javascript
var msg = "Caged base fret position should derived from root note";
var chord = new jtabChord('C');
var cagedBaseShape = chord.cagedBaseShape;
assertNotUndefined( cagedBaseShape );
assertEqual( 'C', cagedBaseShape, msg )
```

--------------------------------

### Chord List Validity Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Ensures all chord names in jtab.ChordList are valid.

```javascript
var msg = "jtab.ChordLists should only contain valid chord names";
var chordList = jtab.ChordList();
for (var key = 0; key < chordList.length; key++) {
    var token = chordList[key];
    assertEqual( "string", typeof(token), token + " expect a String" );
    var chord = new jtabChord(token);
    assert( chord.isValid, "jtabChord('" + token + "') should be valid" );
}
```

--------------------------------

### Chord Scale Association Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Verifies that chords are correctly associated with the Western scale.

```javascript
var msg = "Chords should be based on the western scale";
var chord = new jtabChord('C');
assertEqual( jtab.WesternScale, chord.scale, msg );
assertEqual( jtab.WesternScale.BaseNotes, chord.baseNotes, msg );
```

--------------------------------

### Western Scale Base Notes Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the validity and mapping of base notes in the Western scale.

```javascript
assertNotUndefined( baseNotes, "jtab.WesternScale.BaseNotes should be valid" );
var validBaseNotes = { 
    'C' : [ 'C' , 'C', 0 ], 
    'C#': [ 'C#', 'C', 1 ], 
    'Db': [ 'C#', 'C', 1 ], 
    'D' : [ 'D' , 'D', 0 ], 
    'D#': [ 'Eb', 'D', 1 ], 
    'Eb': [ 'Eb', 'D', 1 ], 
    'E' : [ 'E' , 'E', 0 ], 
    'F' : [ 'F' , 'E', 1 ], 
    'F#': [ 'F#', 'E', 2 ], 
    'Gb': [ 'F#', 'E', 2 ], 
    'G' : [ 'G' , 'G', 0 ], 
    'G#': [ 'G#', 'G', 1 ], 
    'Ab': [ 'G#', 'G', 1 ], 
    'A' : [ 'A' , 'A', 0 ], 
    'A#': [ 'Bb', 'A', 1 ], 
    'Bb': [ 'Bb', 'A', 1 ], 
    'B' : [ 'B' , 'A', 2 ] 
};
assertHashEqual( validBaseNotes, baseNotes, "jtab.WesternScale.BaseNotes should have correct mappings" );
```

--------------------------------

### Western Scale Base Intervals Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the validity and content of base intervals in the Western scale.

```javascript
var baseIntervals = jtab.WesternScale.BaseIntervals;
assertNotUndefined( baseIntervals, "jtab.WesternScale.BaseIntervals should be valid" );
var validBaseIntervals = ['C', 'C#', 'D', 'Eb', 'E', 'F', 'F#', 'G', 'G#', 'A', 'Bb', 'B'];
assertHashEqual( validBaseIntervals, baseIntervals, "jtab.WesternScale.BaseIntervals should have correct 12 notes" );
```

--------------------------------

### CAGED Base Shape Test

Source: https://github.com/tardate/jtab/blob/main/jtab-unittest.html

Tests the `cagedBaseShape` property for various chords to ensure it returns the correct base shape according to the CAGED system.

```javascript
chord = new jtabChord('C#');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'C', cagedBaseShape, msg);
chord = new jtabChord('D');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'D', cagedBaseShape, msg);
chord = new jtabChord('D#');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'D', cagedBaseShape, msg);
chord = new jtabChord('E');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'E', cagedBaseShape, msg);
chord = new jtabChord('Eb');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'D', cagedBaseShape, msg);
chord = new jtabChord('F');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'E', cagedBaseShape, msg);
chord = new jtabChord('F#');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'E', cagedBaseShape, msg);
chord = new jtabChord('G');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'G', cagedBaseShape, msg);
chord = new jtabChord('G#');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'G', cagedBaseShape, msg);
chord = new jtabChord('A');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'A', cagedBaseShape, msg);
chord = new jtabChord('A#');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'A', cagedBaseShape, msg);
chord = new jtabChord('Bb');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'A', cagedBaseShape, msg);
chord = new jtabChord('B');
cagedBaseShape = chord.cagedBaseShape;
assertEqual( 'A', cagedBaseShape, msg);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.