Why is my RBTree not running correctly? I think the color is set to black at first, but I can not understand why

I can not understand why my black red tree does not rotate properly when I try to insert successive nodes such as: 10, 20, 30, 40, 50. I have writes left rotation and right rotation as well as repair functions. But for some reason, it still acts like a binary search tree, not like a black red at the start and not red, and how can I put it in red when I insert a new node.
Here I included my code.

import java.lang. *;
Public class RedBlackTree <T extends Comparable > extends the BST  {
// hush ... you do not need to delete delete for RBtree (lj)
private static final Boolean RED = true;
private static final Boolean BLACK = false;


@Override
public void insert (value T) {
BSTNode node = new BSTNode(value);
root = insertRBT (root, node);
fixViolation (root);
}

Private BSTNode insertRBT (BSTNode root, BSTNode node) {
// BSTNode newNode = new BSTNode(value);
/ * 1. perform a normal BST insertion * /
if (root == null) {
return node;
}
if (node.getData (). compareTo (root.getData ()) < 0) {
            root.setLeft(insertRBT(root.getLeft(), node));
            root.getLeft().setParent(root);
        }
        else if (node.getData().compareTo(root.getData()) > 0) {
root.setRight (insertRBT (root.getRight (), node));
root.getRight (). setParent (root);
}

return the root;
}


private empty lRotate (BSTNode node) {

BSTNode tempRightNode = node.getRight ();
node.setRight (tempRightNode.getLeft ());

if (node.getRight ()! = null) {
node.getRight (). setParent (node);
}

tempRightNode.setParent (node.getParent ());

if (tempRightNode.getParent () == null) {
root = tempRightNode;
}
else if (node ​​== node.getParent (). getLeft ()) {
node.getParent (). setLeft (tempRightNode);
}
other {
node.getParent (). setRight (tempRightNode);
}
tempRightNode.setLeft (node);
node.setParent (tempRightNode);
}

rRotate (BSTNode) empty private node) {
BSTNode tempLeftNode = node.getLeft ();
node.setLeft (tempLeftNode.getRight ());

if (node.getLeft ()! = null) {
node.getLeft (). setParent (node);
}

tempLeftNode.setParent (node.getParent ());

if (tempLeftNode.getParent () == null) {
root = tempLeftNode;
}
else if (node ​​== node.getParent (). getLeft ()) {
node.getParent (). setLeft (tempLeftNode);
}
other {
node.getParent (). setRight (tempLeftNode);
}
tempLeftNode.setRight (node);
node.setParent (tempLeftNode);
}

FixViolation (BSTNode) in private emptiness node) {
BSTNode parentNode = null;
BSTNode grandParentNode = null;

while ((node! = null) && (node.getColor ()! = BLACK) && (node.getParent (). getColor () == RED)) {
parentNode = node.getParent ();
grandParentNode = node.getParent (). getParent ();

if (parentNode == grandParentNode.getLeft ()) {

BSTNode brother = grandParentNode.getRight ();

if (siblings! = null && fratrie.getColor () == RED) {
grandParentNode.setColor (RED);
parentNode.setColor (BLACK);
sibling.setColor (BLACK);
node = grandParentNode;
}
other {
if (node ​​== parentNode.getRight ()) {
lRotate (parentNode);
node = parentNode;
parentNode = node.getParent ();
}

rRotate (grandParentNode);
boolean tempColor = parentNode.getColor ();
parentNode.setColor (grandParentNode.getColor ());
grandParentNode.setColor (tempColor);
node = parentNode;
}
}
other {
BSTNode brother = grandParentNode.getLeft ();

if (siblings! = null && fratrie.getColor () == RED) {
grandParentNode.setColor (RED);
parentNode.setColor (BLACK);
sibling.setColor (BLACK);
node = grandParentNode;
}
other {
if (node ​​== parentNode.getLeft ()) {
rRotate (parentNode);
node = parentNode;
parentNode = node.getParent ();
}

lRotate (grandParentNode);
boolean tempColor = parentNode.getColor ();
parentNode.setColor (grandParentNode.getColor ());
grandParentNode.setColor (tempColor);
node = parentNode;
}
}
}

if (root.getColor () == RED) {
root.setColor (BLACK);
}
}

}

/// node class ////
/ ** A node for our tree * /
class BSTNode <T extends Comparable > {
/ ** contains the int data in the node * /
private T data;
private int height;
private Boolean color;
Private BSTNode parent


/ ** points to the child on the left * /
Private BSTNode left;

/ ** points to the good child * /
Private BSTNode right;

/ ** manufacturer * /
BSTNode public (T data) {
this.data = data;
left = right = parent = null;
height = 1;
this.color = color;
}

/ ** returns the pointer to the child on the left * /
BSTNode public getLeft () {
turn left;
}

/ ** returns the pointer to the right child * /
BSTNode public getRight () {
turn right;
}

BSTNode public getParent () {
returning parent;
}

/ ** returns the int value held inside this node * /
public T getData () {
return data;
}

public int getHeight () {
height of return;
}

public boolean getColor () {
return the color;
}

/ ** place the pointer on the left child * /
public void setLeft (BSTNode left) {
this.left = left;
}

/ ** place the pointer on the right child * /
public void setRight (BSTNode right)
this.right = right;
}

public void setParent (BSTNode parent) {
this.parent = parent;
}

/ ** defines the int data in the node * /
public void setData (T data) {
this.data = data;
}

public void setHeight (int height) {
this.height = height;
}

public void setColor (Boolean color) {
this.color = color;
}

@Override
public channel toString () {
return data.toString ();
}
}